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

**

** All rights reserved.

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

**

** This file is part of the Qt Linguist 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 "profileevaluator.h"

#include "proparserutils.h"

#include "proitems.h"

#include <QtCore/QByteArray>

#include <QtCore/QDateTime>

#include <QtCore/QDebug>

#include <QtCore/QDir>

#include <QtCore/QFile>

#include <QtCore/QFileInfo>

#include <QtCore/QList>

#include <QtCore/QRegExp>

#include <QtCore/QSet>

#include <QtCore/QStack>

#include <QtCore/QString>

#include <QtCore/QStringList>

#include <QtCore/QTextStream>

#ifdef Q_OS_UNIX

#include <unistd.h>

#include <sys/utsname.h>

#else

#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

///////////////////////////////////////////////////////////////////////

//

// Option

//

///////////////////////////////////////////////////////////////////////

QString

Option::fixString(QString string, uchar flags)

{

    // XXX Ripped out caching, so this will be slow. Should not matter for current uses.

    //fix the environment variables

    if (flags & Option::FixEnvVars) {

        int rep;

        QRegExp reg_variableName(QLatin1String("\\$\\(.*\\)"));

        reg_variableName.setMinimal(true);

        while ((rep = reg_variableName.indexIn(string)) != -1)

            string.replace(rep, reg_variableName.matchedLength(),

                           QString::fromLocal8Bit(qgetenv(string.mid(rep + 2, reg_variableName.matchedLength() - 3).toLatin1().constData()).constData()));

    }

    //canonicalize it (and treat as a path)

    if (flags & Option::FixPathCanonicalize) {

#if 0

        string = QFileInfo(string).canonicalFilePath();

#endif

        string = QDir::cleanPath(string);

    }

    if (string.length() > 2 && string[0].isLetter() && string[1] == QLatin1Char(':'))

        string[0] = string[0].toLower();

    //fix separators

    Q_ASSERT(!((flags & Option::FixPathToLocalSeparators) && (flags & Option::FixPathToTargetSeparators)));

    if (flags & Option::FixPathToLocalSeparators) {

#if defined(Q_OS_WIN32)

        string = string.replace(QLatin1Char('/'), QLatin1Char('\\'));

#else

        string = string.replace(QLatin1Char('\\'), QLatin1Char('/'));

#endif

    } else if (flags & Option::FixPathToTargetSeparators) {

        string = string.replace(QLatin1Char('/'), Option::dir_sep)

                       .replace(QLatin1Char('\\'), Option::dir_sep);

    }

    if ((string.startsWith(QLatin1Char('"')) && string.endsWith(QLatin1Char('"'))) ||

        (string.startsWith(QLatin1Char('\'')) && string.endsWith(QLatin1Char('\''))))

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

    return string;

}

///////////////////////////////////////////////////////////////////////

//

// ProFileEvaluator::Private

//

///////////////////////////////////////////////////////////////////////

class ProFileEvaluator::Private : public AbstractProItemVisitor

{

public:

    Private(ProFileEvaluator *q_);

    ProFileEvaluator *q;

    int m_lineNo;                                   // Error reporting

    bool m_verbose;

    /////////////// Reading pro file

    bool read(ProFile *pro);

    ProBlock *currentBlock();

    void updateItem();

    bool parseLine(const QString &line);

    void insertVariable(const QString &line, int *i);

    void insertOperator(const char op);

    void insertComment(const QString &comment);

    void enterScope(bool multiLine);

    void leaveScope();

    void finalizeBlock();

    QStack<ProBlock *> m_blockstack;

    ProBlock *m_block;

    ProItem *m_commentItem;

    QString m_proitem;

    QString m_pendingComment;

    bool m_syntaxError;

    bool m_contNextLine;

    bool m_inQuote;

    int m_parens;

    /////////////// Evaluating pro file contents

    // implementation of AbstractProItemVisitor

    ProItem::ProItemReturn visitBeginProBlock(ProBlock *block);

    void visitEndProBlock(ProBlock *block);

    ProItem::ProItemReturn visitProLoopIteration();

    void visitProLoopCleanup();

    void visitBeginProVariable(ProVariable *variable);

    void visitEndProVariable(ProVariable *variable);

    ProItem::ProItemReturn visitBeginProFile(ProFile *value);

    ProItem::ProItemReturn visitEndProFile(ProFile *value);

    void visitProValue(ProValue *value);

    ProItem::ProItemReturn visitProFunction(ProFunction *function);

    void visitProOperator(ProOperator *oper);

    void visitProCondition(ProCondition *condition);

    QStringList valuesDirect(const QString &variableName) const { return m_valuemap[variableName]; }

    QStringList values(const QString &variableName) const;

    QStringList values(const QString &variableName, const ProFile *pro) const;

    QStringList values(const QString &variableName, const QHash<QString, QStringList> &place,

                       const ProFile *pro) const;

    QString propertyValue(const QString &val) const;

    bool isActiveConfig(const QString &config, bool regex = false);

    QStringList expandVariableReferences(const QString &value);

    void doVariableReplace(QString *str);

    QStringList evaluateExpandFunction(const QString &function, const QString &arguments);

    QString format(const char *format) const;

    QString currentFileName() const;

    QString currentDirectory() const;

    ProFile *currentProFile() const;

    ProItem::ProItemReturn evaluateConditionalFunction(const QString &function, const QString &arguments);

    bool evaluateFile(const QString &fileName);

    bool evaluateFeatureFile(const QString &fileName);

    static inline ProItem::ProItemReturn returnBool(bool b)

        { return b ? ProItem::ReturnTrue : ProItem::ReturnFalse; }

    QStringList evaluateFunction(ProBlock *funcPtr, const QStringList &argumentsList, bool *ok);

    QStringList qmakeFeaturePaths();

    struct State {

        bool condition;

        bool prevCondition;

    } m_sts;

    bool m_invertNext; // Short-lived, so not in State

    int m_skipLevel;

    bool m_cumulative;

    bool m_isFirstVariableValue;

    QString m_lastVarName;

    ProVariable::VariableOperator m_variableOperator;

    QString m_origfile;

    QString m_oldPath;                              // To restore the current path to the path

    QStack<ProFile*> m_profileStack;                // To handle 'include(a.pri), so we can track back to 'a.pro' when finished with 'a.pri'

    struct ProLoop {

        QString variable;

        QStringList oldVarVal;

        QStringList list;

        int index;

        bool infinite;

    };

    QStack<ProLoop> m_loopStack;

    // we need the following two variables for handling

    // CONFIG = foo bar $$CONFIG

    QHash<QString, QStringList> m_tempValuemap;         // used while evaluating (variable operator value1 value2 ...)

    QHash<const ProFile*, QHash<QString, QStringList> > m_tempFilevaluemap; // used while evaluating (variable operator value1 value2 ...)

    QHash<QString, QStringList> m_valuemap;         // VariableName must be us-ascii, the content however can be non-us-ascii.

    QHash<const ProFile*, QHash<QString, QStringList> > m_filevaluemap; // Variables per include file

    QHash<QString, QString> m_properties;

    QString m_outputDir;

    bool m_definingTest;

    QString m_definingFunc;

    QHash<QString, ProBlock *> m_testFunctions;

    QHash<QString, ProBlock *> m_replaceFunctions;

    QStringList m_returnValue;

    QStack<QHash<QString, QStringList> > m_valuemapStack;

    QStack<QHash<const ProFile*, QHash<QString, QStringList> > > m_filevaluemapStack;

    int m_prevLineNo;                               // Checking whether we're assigning the same TARGET

    ProFile *m_prevProFile;                         // See m_prevLineNo

};

Q_DECLARE_TYPEINFO(ProFileEvaluator::Private::State, Q_PRIMITIVE_TYPE);

Q_DECLARE_TYPEINFO(ProFileEvaluator::Private::ProLoop, Q_MOVABLE_TYPE);

ProFileEvaluator::Private::Private(ProFileEvaluator *q_)

  : q(q_)

{

    // Global parser state

    m_prevLineNo = 0;

    m_prevProFile = 0;

    // Configuration, more or less

    m_verbose = true;

    m_cumulative = true;

    // Evaluator state

    m_sts.condition = false;

    m_sts.prevCondition = false;

    m_invertNext = false;

    m_skipLevel = 0;

    m_isFirstVariableValue = true;

    m_definingFunc.clear();

}

bool ProFileEvaluator::Private::read(ProFile *pro)

{

    QFile file(pro->fileName());

    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {

        q->errorMessage(format("%1 not readable.").arg(pro->fileName()));

        return false;

    }

    // Parser state

    m_block = 0;

    m_commentItem = 0;

    m_inQuote = false;

    m_parens = 0;

    m_contNextLine = false;

    m_syntaxError = false;

    m_lineNo = 1;

    m_blockstack.clear();

    m_blockstack.push(pro);

    QTextStream ts(&file);

    while (!ts.atEnd()) {

        QString line = ts.readLine();

        if (!parseLine(line)) {

            q->errorMessage(format(".pro parse failure."));

            return false;

        }

        ++m_lineNo;

    }

    return true;

}

bool ProFileEvaluator::Private::parseLine(const QString &line0)

{

    if (m_blockstack.isEmpty())

        return false;

    int parens = m_parens;

    bool inQuote = m_inQuote;

    bool escaped = false;

    QString line = line0.simplified();

    for (int i = 0; !m_syntaxError && i < line.length(); ++i) {

        ushort c = line.at(i).unicode();

        if (c == '#') { // Yep - no escaping possible

            insertComment(line.mid(i + 1));

            escaped = m_contNextLine;

            break;

        }

        if (!escaped) {

            if (c == '\\') {

                escaped = true;

                m_proitem += c;

                continue;

            } else if (c == '"') {

                inQuote = !inQuote;

                m_proitem += c;

                continue;

            }

        } else {

            escaped = false;

        }

        if (!inQuote) {

            if (c == '(') {

                ++parens;

            } else if (c == ')') {

                --parens;

            } else if (!parens) {

                if (m_block && (m_block->blockKind() & ProBlock::VariableKind)) {

                    if (c == ' ')

                        updateItem();

                    else

                        m_proitem += c;

                    continue;

                }

                if (c == ':') {

                    enterScope(false);

                    continue;

                }

                if (c == '{') {

                    enterScope(true);

                    continue;

                }

                if (c == '}') {

                    leaveScope();

                    continue;

                }

                if (c == '=') {

                    insertVariable(line, &i);

                    continue;

                }

                if (c == '|' || c == '!') {

                    insertOperator(c);

                    continue;

                }

            }

        }

        m_proitem += c;

    }

    m_inQuote = inQuote;

    m_parens = parens;

    m_contNextLine = escaped;

    if (escaped) {

        m_proitem.chop(1);

        updateItem();

        return true;

    } else {

        if (!m_syntaxError) {

            updateItem();

            finalizeBlock();

            return true;

        }

        return false;

    }

}

void ProFileEvaluator::Private::finalizeBlock()

{

    if (m_blockstack.isEmpty()) {

        m_syntaxError = true;

    } else {

        if (m_blockstack.top()->blockKind() & ProBlock::SingleLine)

            leaveScope();

        m_block = 0;

        m_commentItem = 0;

    }

}

void ProFileEvaluator::Private::insertVariable(const QString &line, int *i)

{

    ProVariable::VariableOperator opkind;

    if (m_proitem.isEmpty()) // Line starting with '=', like a conflict marker

        return;

    switch (m_proitem.at(m_proitem.length() - 1).unicode()) {

        case '+':

            m_proitem.chop(1);

            opkind = ProVariable::AddOperator;

            break;

        case '-':

            m_proitem.chop(1);

            opkind = ProVariable::RemoveOperator;

            break;

        case '*':

            m_proitem.chop(1);

            opkind = ProVariable::UniqueAddOperator;

            break;

        case '~':

            m_proitem.chop(1);

            opkind = ProVariable::ReplaceOperator;

            break;

        default:

            opkind = ProVariable::SetOperator;

    }

    ProBlock *block = m_blockstack.top();

    m_proitem = m_proitem.trimmed();

    ProVariable *variable = new ProVariable(m_proitem, block);

    variable->setLineNumber(m_lineNo);

    variable->setVariableOperator(opkind);

    block->appendItem(variable);

    m_block = variable;

    if (!m_pendingComment.isEmpty()) {

        m_block->setComment(m_pendingComment);

        m_pendingComment.clear();

    }

    m_commentItem = variable;

    m_proitem.clear();

    if (opkind == ProVariable::ReplaceOperator) {

        // skip util end of line or comment

        while (1) {

            ++(*i);

            // end of line?

            if (*i >= line.count())

                break;

            // comment?

            if (line.at(*i).unicode() == '#') {

                --(*i);

                break;

            }

            m_proitem += line.at(*i);

        }

        m_proitem = m_proitem.trimmed();

    }

}

void ProFileEvaluator::Private::insertOperator(const char op)

{

    updateItem();

    ProOperator::OperatorKind opkind;

    switch(op) {

        case '!':

            opkind = ProOperator::NotOperator;

            break;

        case '|':

            opkind = ProOperator::OrOperator;

            break;

        default:

            opkind = ProOperator::OrOperator;

    }

    ProBlock * const block = currentBlock();

    ProOperator * const proOp = new ProOperator(opkind);

    proOp->setLineNumber(m_lineNo);

    block->appendItem(proOp);

    m_commentItem = proOp;

}

void ProFileEvaluator::Private::insertComment(const QString &comment)

{

    updateItem();

    QString strComment;

    if (!m_commentItem)

        strComment = m_pendingComment;

    else

        strComment = m_commentItem->comment();

    if (strComment.isEmpty())

        strComment = comment;

    else {

        strComment += QLatin1Char('\n');

        strComment += comment.trimmed();

    }

    strComment = strComment.trimmed();

    if (!m_commentItem)

        m_pendingComment = strComment;

    else

        m_commentItem->setComment(strComment);

}

void ProFileEvaluator::Private::enterScope(bool multiLine)

{

    updateItem();

    ProBlock *parent = currentBlock();

    ProBlock *block = new ProBlock(parent);