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

**

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

#include "property.h"

#include "option.h"

#include "cachekeys.h"

#include "epocroot.h"

#include <qdatetime.h>

#include <qfile.h>

#include <qfileinfo.h>

#include <qdir.h>

#include <qregexp.h>

#include <qtextstream.h>

#include <qstack.h>

#include <qhash.h>

#include <qdebug.h>

#ifdef Q_OS_UNIX

#include <unistd.h>

#include <sys/utsname.h>

#elif defined(Q_OS_WIN32)

#include <windows.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#ifdef Q_OS_WIN32

#define QT_POPEN _popen

#define QT_PCLOSE _pclose

#else

#define QT_POPEN popen

#define QT_PCLOSE pclose

#endif

QT_BEGIN_NAMESPACE

//expand fucntions

enum ExpandFunc { E_MEMBER=1, E_FIRST, E_LAST, E_CAT, E_FROMFILE, E_EVAL, E_LIST,

                  E_SPRINTF, E_JOIN, E_SPLIT, E_BASENAME, E_DIRNAME, E_SECTION,

                  E_FIND, E_SYSTEM, E_UNIQUE, E_QUOTE, E_ESCAPE_EXPAND,

                  E_UPPER, E_LOWER, E_FILES, E_PROMPT, E_RE_ESCAPE, E_REPLACE,

                  E_SIZE, E_GENERATE_UID };

QMap<QString, ExpandFunc> qmake_expandFunctions()

{

    static QMap<QString, ExpandFunc> *qmake_expand_functions = 0;

    if(!qmake_expand_functions) {

        qmake_expand_functions = new QMap<QString, ExpandFunc>;

        qmakeAddCacheClear(qmakeDeleteCacheClear_QMapStringInt, (void**)&qmake_expand_functions);

        qmake_expand_functions->insert("member", E_MEMBER);

        qmake_expand_functions->insert("first", E_FIRST);

        qmake_expand_functions->insert("last", E_LAST);

        qmake_expand_functions->insert("cat", E_CAT);

        qmake_expand_functions->insert("fromfile", E_FROMFILE);

        qmake_expand_functions->insert("eval", E_EVAL);

        qmake_expand_functions->insert("list", E_LIST);

        qmake_expand_functions->insert("sprintf", E_SPRINTF);

        qmake_expand_functions->insert("join", E_JOIN);

        qmake_expand_functions->insert("split", E_SPLIT);

        qmake_expand_functions->insert("basename", E_BASENAME);

        qmake_expand_functions->insert("dirname", E_DIRNAME);

        qmake_expand_functions->insert("section", E_SECTION);

        qmake_expand_functions->insert("find", E_FIND);

        qmake_expand_functions->insert("system", E_SYSTEM);

        qmake_expand_functions->insert("unique", E_UNIQUE);

        qmake_expand_functions->insert("quote", E_QUOTE);

        qmake_expand_functions->insert("escape_expand", E_ESCAPE_EXPAND);

        qmake_expand_functions->insert("upper", E_UPPER);

        qmake_expand_functions->insert("lower", E_LOWER);

        qmake_expand_functions->insert("re_escape", E_RE_ESCAPE);

        qmake_expand_functions->insert("files", E_FILES);

        qmake_expand_functions->insert("prompt", E_PROMPT);

        qmake_expand_functions->insert("replace", E_REPLACE);

        qmake_expand_functions->insert("size", E_SIZE);

        qmake_expand_functions->insert("generate_uid", E_GENERATE_UID);

    }

    return *qmake_expand_functions;

}

//replace functions

enum TestFunc { T_REQUIRES=1, T_GREATERTHAN, T_LESSTHAN, T_EQUALS,

                T_EXISTS, T_EXPORT, T_CLEAR, T_UNSET, T_EVAL, T_CONFIG, T_SYSTEM,

                T_RETURN, T_BREAK, T_NEXT, T_DEFINED, T_CONTAINS, T_INFILE,

                T_COUNT, T_ISEMPTY, T_INCLUDE, T_LOAD, T_DEBUG, T_ERROR,

                T_MESSAGE, T_WARNING, T_IF };

QMap<QString, TestFunc> qmake_testFunctions()

{

    static QMap<QString, TestFunc> *qmake_test_functions = 0;

    if(!qmake_test_functions) {

        qmake_test_functions = new QMap<QString, TestFunc>;

        qmake_test_functions->insert("requires", T_REQUIRES);

        qmake_test_functions->insert("greaterThan", T_GREATERTHAN);

        qmake_test_functions->insert("lessThan", T_LESSTHAN);

        qmake_test_functions->insert("equals", T_EQUALS);

        qmake_test_functions->insert("isEqual", T_EQUALS);

        qmake_test_functions->insert("exists", T_EXISTS);

        qmake_test_functions->insert("export", T_EXPORT);

        qmake_test_functions->insert("clear", T_CLEAR);

        qmake_test_functions->insert("unset", T_UNSET);

        qmake_test_functions->insert("eval", T_EVAL);

        qmake_test_functions->insert("CONFIG", T_CONFIG);

        qmake_test_functions->insert("if", T_IF);

        qmake_test_functions->insert("isActiveConfig", T_CONFIG);

        qmake_test_functions->insert("system", T_SYSTEM);

        qmake_test_functions->insert("return", T_RETURN);

        qmake_test_functions->insert("break", T_BREAK);

        qmake_test_functions->insert("next", T_NEXT);

        qmake_test_functions->insert("defined", T_DEFINED);

        qmake_test_functions->insert("contains", T_CONTAINS);

        qmake_test_functions->insert("infile", T_INFILE);

        qmake_test_functions->insert("count", T_COUNT);

        qmake_test_functions->insert("isEmpty", T_ISEMPTY);

        qmake_test_functions->insert("include", T_INCLUDE);

        qmake_test_functions->insert("load", T_LOAD);

        qmake_test_functions->insert("debug", T_DEBUG);

        qmake_test_functions->insert("error", T_ERROR);

        qmake_test_functions->insert("message", T_MESSAGE);

        qmake_test_functions->insert("warning", T_WARNING);

    }

    return *qmake_test_functions;

}

struct parser_info {

    QString file;

    int line_no;

    bool from_file;

} parser;

static QString remove_quotes(const QString &arg)

{

    const ushort SINGLEQUOTE = '\'';

    const ushort DOUBLEQUOTE = '"';

    const QChar *arg_data = arg.data();

    const ushort first = arg_data->unicode();

    const int arg_len = arg.length();

    if(first == SINGLEQUOTE || first == DOUBLEQUOTE) {

        const ushort last = (arg_data+arg_len-1)->unicode();

        if(last == first)

            return arg.mid(1, arg_len-2);

    }

    return arg;

}

static QString varMap(const QString &x)

{

    QString ret(x);

    if(ret.startsWith("TMAKE")) //tmake no more!

        ret = "QMAKE" + ret.mid(5);

    else if(ret == "INTERFACES")

        ret = "FORMS";

    else if(ret == "QMAKE_POST_BUILD")

        ret = "QMAKE_POST_LINK";

    else if(ret == "TARGETDEPS")

        ret = "POST_TARGETDEPS";

    else if(ret == "LIBPATH")

        ret = "QMAKE_LIBDIR";

    else if(ret == "QMAKE_EXT_MOC")

        ret = "QMAKE_EXT_CPP_MOC";

    else if(ret == "QMAKE_MOD_MOC")

        ret = "QMAKE_H_MOD_MOC";

    else if(ret == "QMAKE_LFLAGS_SHAPP")

        ret = "QMAKE_LFLAGS_APP";

    else if(ret == "PRECOMPH")

        ret = "PRECOMPILED_HEADER";

    else if(ret == "PRECOMPCPP")

        ret = "PRECOMPILED_SOURCE";

    else if(ret == "INCPATH")

        ret = "INCLUDEPATH";

    else if(ret == "QMAKE_EXTRA_WIN_COMPILERS" || ret == "QMAKE_EXTRA_UNIX_COMPILERS")

        ret = "QMAKE_EXTRA_COMPILERS";

    else if(ret == "QMAKE_EXTRA_WIN_TARGETS" || ret == "QMAKE_EXTRA_UNIX_TARGETS")

        ret = "QMAKE_EXTRA_TARGETS";

    else if(ret == "QMAKE_EXTRA_UNIX_INCLUDES")

        ret = "QMAKE_EXTRA_INCLUDES";

    else if(ret == "QMAKE_EXTRA_UNIX_VARIABLES")

        ret = "QMAKE_EXTRA_VARIABLES";

    else if(ret == "QMAKE_RPATH")

        ret = "QMAKE_LFLAGS_RPATH";

    else if(ret == "QMAKE_FRAMEWORKDIR")

        ret = "QMAKE_FRAMEWORKPATH";

    else if(ret == "QMAKE_FRAMEWORKDIR_FLAGS")

        ret = "QMAKE_FRAMEWORKPATH_FLAGS";

    return ret;

}

static QStringList split_arg_list(QString params)

{

    int quote = 0;

    QStringList args;

    const ushort LPAREN = '(';

    const ushort RPAREN = ')';

    const ushort SINGLEQUOTE = '\'';

    const ushort DOUBLEQUOTE = '"';

    const ushort COMMA = ',';

    const ushort SPACE = ' ';

    //const ushort TAB = '\t';

    ushort unicode;

    const QChar *params_data = params.data();

    const int params_len = params.length();

    int last = 0;

    while(last < params_len && (params_data[last].unicode() == SPACE

                                /*|| params_data[last].unicode() == TAB*/))

        ++last;

    for(int x = last, parens = 0; x <= params_len; x++) {

        unicode = params_data[x].unicode();

        if(x == params_len) {

            while(x && params_data[x-1].unicode() == SPACE)

                --x;

            QString mid(params_data+last, x-last);

            if(quote) {

                if(mid[0] == quote && mid[(int)mid.length()-1] == quote)

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

                quote = 0;

            }

            args << mid;

            break;

        }

        if(unicode == LPAREN) {

            --parens;

        } else if(unicode == RPAREN) {

            ++parens;

        } else if(quote && unicode == quote) {

            quote = 0;

        } else if(!quote && (unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE)) {

            quote = unicode;

        }

        if(!parens && !quote && unicode == COMMA) {

            QString mid = params.mid(last, x - last).trimmed();

            args << mid;

            last = x+1;

            while(last < params_len && (params_data[last].unicode() == SPACE

                                        /*|| params_data[last].unicode() == TAB*/))

                ++last;

        }

    }

    return args;

}

static QStringList split_value_list(const QString &vals, bool do_semicolon=false)

{

    QString build;

    QStringList ret;

    QStack<char> quote;

    const ushort LPAREN = '(';

    const ushort RPAREN = ')';

    const ushort SINGLEQUOTE = '\'';

    const ushort DOUBLEQUOTE = '"';

    const ushort BACKSLASH = '\\';

    const ushort SEMICOLON = ';';

    ushort unicode;

    const QChar *vals_data = vals.data();

    const int vals_len = vals.length();

    for(int x = 0, parens = 0; x < vals_len; x++) {

        unicode = vals_data[x].unicode();

        if(x != (int)vals_len-1 && unicode == BACKSLASH &&

            (vals_data[x+1].unicode() == SINGLEQUOTE || vals_data[x+1].unicode() == DOUBLEQUOTE)) {

            build += vals_data[x++]; //get that 'escape'

        } else if(!quote.isEmpty() && unicode == quote.top()) {

            quote.pop();

        } else if(unicode == SINGLEQUOTE || unicode == DOUBLEQUOTE) {

            quote.push(unicode);

        } else if(unicode == RPAREN) {

            --parens;

        } else if(unicode == LPAREN) {

            ++parens;

        }

        if(!parens && quote.isEmpty() && ((do_semicolon && unicode == SEMICOLON) ||

                                           vals_data[x] == Option::field_sep)) {

            ret << build;

            build.clear();

        } else {

            build += vals_data[x];

        }

    }

    if(!build.isEmpty())

        ret << build;

    return ret;

}

//just a parsable entity

struct ParsableBlock

{

    ParsableBlock() : ref_cnt(1) { }

    virtual ~ParsableBlock() { }

    struct Parse {

        QString text;

        parser_info pi;

        Parse(const QString &t) : text(t){ pi = parser; }

    };

    QList<Parse> parselist;

    inline int ref() { return ++ref_cnt; }

    inline int deref() { return --ref_cnt; }

protected:

    int ref_cnt;

    virtual bool continueBlock() = 0;

    bool eval(QMakeProject *p, QMap<QString, QStringList> &place);

};

bool ParsableBlock::eval(QMakeProject *p, QMap<QString, QStringList> &place)

{

    //save state

    parser_info pi = parser;

    const int block_count = p->scope_blocks.count();

    //execute

    bool ret = true;

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

        parser = parselist.at(i).pi;

        if(!(ret = p->parse(parselist.at(i).text, place)) || !continueBlock())

            break;

    }

    //restore state

    parser = pi;

    while(p->scope_blocks.count() > block_count)

        p->scope_blocks.pop();

    return ret;

}

//defined functions

struct FunctionBlock : public ParsableBlock

{

    FunctionBlock() : calling_place(0), scope_level(1), cause_return(false) { }

    QMap<QString, QStringList> vars;

    QMap<QString, QStringList> *calling_place;

    QStringList return_value;

    int scope_level;

    bool cause_return;

    bool exec(const QList<QStringList> &args,

              QMakeProject *p, QMap<QString, QStringList> &place, QStringList &functionReturn);

    virtual bool continueBlock() { return !cause_return; }

};

bool FunctionBlock::exec(const QList<QStringList> &args,

                         QMakeProject *proj, QMap<QString, QStringList> &place,

                         QStringList &functionReturn)

{

    //save state

#if 1

    calling_place = &place;

#else

    calling_place = &proj->variables();

#endif

    return_value.clear();

    cause_return = false;

    //execute

#if 0

    vars = proj->variables(); // should be place so that local variables can be inherited

#else

    vars = place;

#endif

    vars["ARGS"].clear();

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

        vars["ARGS"] += args[i];

        vars[QString::number(i+1)] = args[i];

    }

    bool ret = ParsableBlock::eval(proj, vars);

    functionReturn = return_value;

    //restore state

    calling_place = 0;

    return_value.clear();

    vars.clear();

    return ret;

}

//loops

struct IteratorBlock : public ParsableBlock

{

    IteratorBlock() : scope_level(1), loop_forever(false), cause_break(false), cause_next(false) { }

    int scope_level;

    struct Test {

        QString func;

        QStringList args;

        bool invert;

        parser_info pi;

        Test(const QString &f, QStringList &a, bool i) : func(f), args(a), invert(i) { pi = parser; }

    };

    QList<Test> test;

    QString variable;

    bool loop_forever, cause_break, cause_next;

    QStringList list;

    bool exec(QMakeProject *p, QMap<QString, QStringList> &place);

    virtual bool continueBlock() { return !cause_next && !cause_break; }

};

bool IteratorBlock::exec(QMakeProject *p, QMap<QString, QStringList> &place)

{

    bool ret = true;

    QStringList::Iterator it;

    if(!loop_forever)

        it = list.begin();

    int iterate_count = 0;

    //save state

    IteratorBlock *saved_iterator = p->iterator;

    p->iterator = this;

    //do the loop

    while(loop_forever || it != list.end()) {

        cause_next = cause_break = false;

        if(!loop_forever && (*it).isEmpty()) { //ignore empty items

            ++it;

            continue;

        }

        //set up the loop variable

        QStringList va;

        if(!variable.isEmpty()) {

            va = place[variable];

            if(loop_forever)

                place[variable] = QStringList(QString::number(iterate_count));

            else

                place[variable] = QStringList(*it);

        }

        //do the iterations

        bool succeed = true;

        for(QList<Test>::Iterator test_it = test.begin(); test_it != test.end(); ++test_it) {

            parser = (*test_it).pi;

            succeed = p->doProjectTest((*test_it).func, (*test_it).args, place);

            if((*test_it).invert)

                succeed = !succeed;

            if(!succeed)

                break;

        }

        if(succeed)

            ret = ParsableBlock::eval(p, place);

        //restore the variable in the map

        if(!variable.isEmpty())

            place[variable] = va;

        //loop counters

        if(!loop_forever)

            ++it;

        iterate_count++;

        if(!ret || cause_break)

            break;

    }

    //restore state

    p->iterator = saved_iterator;

    return ret;

}

QMakeProject::ScopeBlock::~ScopeBlock()

{

#if 0

    if(iterate)

        delete iterate;

#endif

}

static void qmake_error_msg(const QString &msg)

{

    fprintf(stderr, "%s:%d: %s\n", parser.file.toLatin1().constData(), parser.line_no,

            msg.toLatin1().constData());

}

enum isForSymbian_enum {

    isForSymbian_NOT_SET = -1,

    isForSymbian_FALSE = 0,

    isForSymbian_ABLD = 1,

    isForSymbian_SBSV2 = 2,

};

static isForSymbian_enum isForSymbian_value = isForSymbian_NOT_SET;

// Checking for symbian build is primarily determined from the qmake spec,

// but if that is not specified, detect if symbian is the default spec

// by checking the MAKEFILE_GENERATOR variable value.

static void init_symbian(const QMap<QString, QStringList>& vars)

{

    if (isForSymbian_value != isForSymbian_NOT_SET)

        return;