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

**

** 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 Qt Mobility Components.

**

** $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$

**

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

/*

  Copyright 2005 Roberto Raggi <roberto@kdevelop.org>

  Permission to use, copy, modify, distribute, and sell this software and its

  documentation for any purpose is hereby granted without fee, provided that

  the above copyright notice appear in all copies and that both that

  copyright notice and this permission notice appear in supporting

  documentation.

  The above copyright notice and this permission notice shall be included in

  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE

  KDEVELOP TEAM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

  AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

  CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

*/

#include "pp.h"

#include "pp-cctype.h"

#include <Lexer.h>

#include <Token.h>

#include <Literals.h>

#include <cctype>

#include <QtDebug>

#include <algorithm>

namespace CPlusPlus {

struct Value

{

    enum Kind {

        Kind_Long,

        Kind_ULong

    };

    Kind kind;

    union {

        long l;

        unsigned long ul;

    };

    Value()

        : kind(Kind_Long), l(0)

    { }

    inline bool is_ulong () const

    { return kind == Kind_ULong; }

    inline void set_ulong (unsigned long v)

    {

        ul = v;

        kind = Kind_ULong;

    }

    inline void set_long (long v)

    {

        l = v;

        kind = Kind_Long;

    }

    inline bool is_zero () const

    { return l == 0; }

#define PP_DEFINE_BIN_OP(name, op) \

    inline Value operator op(const Value &other) const \

    { \

        Value v = *this; \

        if (v.is_ulong () || other.is_ulong ()) \

            v.set_ulong (v.ul op other.ul); \

        else \

            v.set_long (v.l op other.l); \

        return v; \

    }

    PP_DEFINE_BIN_OP(op_add, +)

    PP_DEFINE_BIN_OP(op_sub, -)

    PP_DEFINE_BIN_OP(op_mult, *)

    PP_DEFINE_BIN_OP(op_div, /)

    PP_DEFINE_BIN_OP(op_mod, %)

    PP_DEFINE_BIN_OP(op_lhs, <<)

    PP_DEFINE_BIN_OP(op_rhs, >>)

    PP_DEFINE_BIN_OP(op_lt, <)

    PP_DEFINE_BIN_OP(op_gt, >)

    PP_DEFINE_BIN_OP(op_le, <=)

    PP_DEFINE_BIN_OP(op_ge, >=)

    PP_DEFINE_BIN_OP(op_eq, ==)

    PP_DEFINE_BIN_OP(op_ne, !=)

    PP_DEFINE_BIN_OP(op_bit_and, &)

    PP_DEFINE_BIN_OP(op_bit_or, |)

    PP_DEFINE_BIN_OP(op_bit_xor, ^)

    PP_DEFINE_BIN_OP(op_and, &&)

    PP_DEFINE_BIN_OP(op_or, ||)

#undef PP_DEFINE_BIN_OP

};

} // end of namespace CPlusPlus

using namespace CPlusPlus;

namespace {

bool isMacroDefined(QByteArray name, unsigned offset, Environment *env, Client *client)

{

    Macro *m = env->resolve(name);

    if (client) {

        if (m)

            client->passedMacroDefinitionCheck(offset, *m);

        else

            client->failedMacroDefinitionCheck(offset, name);

    }

    return m != 0;

}

class RangeLexer

{

    const Token *first;

    const Token *last;

    Token trivial;

public:

    inline RangeLexer(const Token *first, const Token *last)

        : first(first), last(last)

    {

        // WARN: `last' must be a valid iterator.

        trivial.offset = last->offset;

    }

    inline operator bool() const

    { return first != last; }

    inline bool isValid() const

    { return first != last; }

    inline int size() const

    { return std::distance(first, last); }

    inline const Token *dot() const

    { return first; }

    inline const Token &operator*() const

    {

        if (first != last)

            return *first;

        return trivial;

    }

    inline const Token *operator->() const

    {

        if (first != last)

            return first;

        return &trivial;

    }

    inline RangeLexer &operator++()

    {

        ++first;

        return *this;

    }

};

class ExpressionEvaluator

{

    ExpressionEvaluator(const ExpressionEvaluator &other);

    void operator = (const ExpressionEvaluator &other);

public:

    ExpressionEvaluator(Client *client, Environment *env)

        : client(client), env(env), _lex(0)

    { }

    Value operator()(const Token *firstToken, const Token *lastToken,

                     const QByteArray &source)

    {

        this->source = source;

        const Value previousValue = switchValue(Value());

        RangeLexer tmp(firstToken, lastToken);

        RangeLexer *previousLex = _lex;

        _lex = &tmp;

        process_expression();

        _lex = previousLex;

        return switchValue(previousValue);

    }

protected:

    Value switchValue(const Value &value)

    {

        Value previousValue = _value;

        _value = value;

        return previousValue;

    }

    bool isTokenDefined() const

    {

        if ((*_lex)->isNot(T_IDENTIFIER))

            return false;

        const QByteArray spell = tokenSpell();

        if (spell.size() != 7)

            return false;

        return spell == "defined";

    }

    QByteArray tokenSpell() const

    {

        const QByteArray text = QByteArray::fromRawData(source.constData() + (*_lex)->offset,

                                                        (*_lex)->f.length);

        return text;

    }

    inline void process_expression()

    { process_constant_expression(); }

    void process_primary()

    {

        if ((*_lex)->is(T_NUMERIC_LITERAL)) {

            int base = 10;

            const QByteArray spell = tokenSpell();

            if (spell.at(0) == '0') {

                if (spell.size() > 1 && (spell.at(1) == 'x' || spell.at(1) == 'X'))

                    base = 16;

                else

                    base = 8;

            }

            _value.set_long(tokenSpell().toLong(0, base));

            ++(*_lex);

        } else if (isTokenDefined()) {

            ++(*_lex);

            if ((*_lex)->is(T_IDENTIFIER)) {

                _value.set_long(isMacroDefined(tokenSpell(), (*_lex)->offset, env, client));

                ++(*_lex);

            } else if ((*_lex)->is(T_LPAREN)) {

                ++(*_lex);

                if ((*_lex)->is(T_IDENTIFIER)) {

                    _value.set_long(isMacroDefined(tokenSpell(), (*_lex)->offset, env, client));

                    ++(*_lex);

                    if ((*_lex)->is(T_RPAREN)) {

                        ++(*_lex);

                    }

                }

            }

        } else if ((*_lex)->is(T_IDENTIFIER)) {

            _value.set_long(0);

            ++(*_lex);

        } else if ((*_lex)->is(T_MINUS)) {

            ++(*_lex);

            process_primary();

            _value.set_long(- _value.l);

        } else if ((*_lex)->is(T_PLUS)) {

            ++(*_lex);

            process_primary();

        } else if ((*_lex)->is(T_EXCLAIM)) {

            ++(*_lex);

            process_primary();

            _value.set_long(_value.is_zero());

        } else if ((*_lex)->is(T_LPAREN)) {

            ++(*_lex);

            process_expression();

            if ((*_lex)->is(T_RPAREN))

                ++(*_lex);

        }

    }

    Value process_expression_with_operator_precedence(const Value &lhs, int minPrecedence)

    {

        Value result = lhs;

        while (precedence((*_lex)->kind()) >= minPrecedence) {

            const int oper = (*_lex)->kind();

            const int operPrecedence = precedence(oper);

            ++(*_lex);

            process_primary();

            Value rhs = _value;

            for (int LA_token_kind = (*_lex)->kind(), LA_precedence = precedence(LA_token_kind);

                    LA_precedence > operPrecedence && isBinaryOperator(LA_token_kind);

                    LA_token_kind = (*_lex)->kind(), LA_precedence = precedence(LA_token_kind)) {

                rhs = process_expression_with_operator_precedence(rhs, LA_precedence);

            }

            result = evaluate_expression(oper, result, rhs);

        }

        return result;

    }

    void process_constant_expression()

    {

        process_primary();

        _value = process_expression_with_operator_precedence(_value, precedence(T_PIPE_PIPE));

        if ((*_lex)->is(T_QUESTION)) {

            const Value cond = _value;

            ++(*_lex);

            process_constant_expression();

            Value left = _value, right;

            if ((*_lex)->is(T_COLON)) {

                ++(*_lex);

                process_constant_expression();

                right = _value;

            }

            _value = ! cond.is_zero() ? left : right;

        }

    }

private:

    inline int precedence(int tokenKind) const

    {

        switch (tokenKind) {

        case T_PIPE_PIPE:       return 0;

        case T_AMPER_AMPER:     return 1;

        case T_PIPE:            return 2;

        case T_CARET:           return 3;

        case T_AMPER:           return 4;

        case T_EQUAL_EQUAL:

        case T_EXCLAIM_EQUAL:   return 5;

        case T_GREATER:

        case T_LESS:

        case T_LESS_EQUAL:

        case T_GREATER_EQUAL:   return 6;

        case T_LESS_LESS:

        case T_GREATER_GREATER: return 7;

        case T_PLUS:

        case T_MINUS:           return 8;

        case T_STAR:

        case T_SLASH:

        case T_PERCENT:         return 9;

        default:

            return -1;

        }

    }

    static inline bool isBinaryOperator(int tokenKind)

    {

        switch (tokenKind) {

        case T_PIPE_PIPE:

        case T_AMPER_AMPER:

        case T_PIPE:

        case T_CARET:

        case T_AMPER:

        case T_EQUAL_EQUAL:

        case T_EXCLAIM_EQUAL:

        case T_GREATER:

        case T_LESS:

        case T_LESS_EQUAL:

        case T_GREATER_EQUAL:

        case T_LESS_LESS:

        case T_GREATER_GREATER:

        case T_PLUS:

        case T_MINUS:

        case T_STAR:

        case T_SLASH:

        case T_PERCENT:

            return true;

        default:

            return false;

        }

    }

    static inline Value evaluate_expression(int tokenKind, const Value &lhs, const Value &rhs)

    {

        switch (tokenKind) {

        case T_PIPE_PIPE:       return lhs || rhs;

        case T_AMPER_AMPER:     return lhs && rhs;

        case T_PIPE:            return lhs | rhs;

        case T_CARET:           return lhs ^ rhs;

        case T_AMPER:           return lhs & rhs;

        case T_EQUAL_EQUAL:     return lhs == rhs;

        case T_EXCLAIM_EQUAL:   return lhs != rhs;

        case T_GREATER:         return lhs > rhs;

        case T_LESS:            return lhs < rhs;

        case T_LESS_EQUAL:      return lhs <= rhs;

        case T_GREATER_EQUAL:   return lhs >= rhs;

        case T_LESS_LESS:       return lhs << rhs;

        case T_GREATER_GREATER: return lhs >> rhs;

        case T_PLUS:            return lhs + rhs;

        case T_MINUS:           return lhs - rhs;

        case T_STAR:            return lhs * rhs;

        case T_SLASH:           return rhs.is_zero() ? Value() : lhs / rhs;

        case T_PERCENT:         return rhs.is_zero() ? Value() : lhs % rhs;

        default:

            return Value();

        }

    }

private:

    Client *client;

    Environment *env;

    QByteArray source;

    RangeLexer *_lex;

    Value _value;

};

} // end of anonymous namespace

Preprocessor::Preprocessor(Client *client, Environment *env)

    : client(client),

      env(env),

      _expand(env),

      _skipping(MAX_LEVEL),

      _trueTest(MAX_LEVEL),

      _dot(_tokens.end()),

      _result(0),

      _markGeneratedTokens(false),

      _expandMacros(true)

{

    resetIfLevel ();

}

void Preprocessor::pushState(const State &s)

{

    _savedStates.append(state());

    _source = s.source;

    _tokens = s.tokens;

    _dot = s.dot;

}

Preprocessor::State Preprocessor::state() const

{

    State state;

    state.source = _source;

    state.tokens = _tokens;

    state.dot = _dot;

    return state;

}

void Preprocessor::popState()

{

    const State &state = _savedStates.last();

    _source = state.source;

    _tokens = state.tokens;

    _dot = state.dot;

    _savedStates.removeLast();

}

QByteArray Preprocessor::operator()(const QString &fileName, const QString &source)

{

    const QString previousOriginalSource = _originalSource;

    _originalSource = source;

    const QByteArray bytes = source.toLatin1();

    const QByteArray preprocessedCode = operator()(fileName, bytes);

    _originalSource = previousOriginalSource;

    return preprocessedCode;

}

QByteArray Preprocessor::operator()(const QString &fileName,

                                    const QByteArray &source)

{

    QByteArray preprocessed;

    preprocess(fileName, source, &preprocessed);

    return preprocessed;

}

QByteArray Preprocessor::expand(const QByteArray &source)

{

    QByteArray result;

    result.reserve(256);

    expand(source, &result);

    return result;

}

void Preprocessor::expand(const QByteArray &source, QByteArray *result)

{

    if (result)

        _expand(source, result);

}

void Preprocessor::expand(const char *first, const char *last, QByteArray *result)

{

    const QByteArray source = QByteArray::fromRawData(first, last - first);

    return expand(source, result);

}

void Preprocessor::out(const QByteArray &text)