/*

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of SourcePawn.

 *

 * SourcePawn is free software: you can redistribute it and/or modify it under

 * the terms of the GNU General Public License as published by the Free

 * Software Foundation, either version 3 of the License, or (at your option)

 * any later version.

 * 

 * SourcePawn is distributed in the hope that it will be useful, but WITHOUT ANY

 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

 * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License along with

 * SourcePawn. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_sp2_hir_h_

#define _include_sp2_hir_h_

#include "../Types.h"

#include "../PoolAllocator.h"

#include "../Opcodes.h"

#include "Symbols.h"

namespace ke {

#define HIR_OPS(_)                      \

    _(Call)                             \

    _(Boolean)                          \

    _(Integer)                          \

    _(Float)                            \

    _(String)                           \

    _(Array)                            \

    _(Store)                            \

    _(ToRef)                            \

    _(NewDependentArray)                \

    /* Special LValue types */          \

    _(Index)                            \

    _(Local)                            \

    _(Global)                           \

    /* End LValues */                   \

    _(Unary)                            \

    _(Binary)                           \

    _(Convert)                          \

    _(PostIncDec)

// Forward declarations.

#define _(name)    class H##name;

HIR_OPS(_)

#undef _

class HIRVisitor;

class AstNode;

class HLValue;

class Array;

class HIR : public PoolObject

{

  public:

    enum HOp {

#define _(name) k##name,

        HIR_OPS(_)

#undef _

        kTotalOps

    };

  public:

    HIR(AstNode *node, Type *type)

      : node_(node),

        type_(type)

    {

    }

    Handle<Type> type() {

        return type_;

    }

    AstNode *node() const {

        return node_;

    }

    virtual bool isLValue() const {

        return false;

    }

    virtual HOp op() const = 0;

    virtual void accept(HIRVisitor *visitor) = 0;

#define _(name)                                         \

    bool is##name() const {                             \

        return op() == k##name;                         \

    }                                                   \

    H##name *to##name() {                               \

        assert(is##name());                             \

        return reinterpret_cast<H##name *>(this);       \

    }

    HIR_OPS(_)

#undef _

    HLValue *toLValue() {

        assert(isLValue());

        return reinterpret_cast<HLValue *>(this);

    }

  private:

    AstNode *node_;

    ScopedRoot<Type> type_;

};

class BytecodeEmitter;

class HIRVisitor

{

  public:

#define _(name)                                 \

    virtual void visit##name(H##name *hir) {    \

        assert(false);                          \

    }

    HIR_OPS(_)

#undef _

};

typedef PoolList<HIR *> HIRList;

#define DEFINE_HIR(name)                        \

    virtual HOp op() const {                    \

        return k##name;                         \

    }                                           \

    virtual void accept(HIRVisitor *visitor) {  \

        visitor->visit##name(this);             \

    }

class HBoolean : public HIR

{

  public:

    HBoolean(AstNode *node, Type *type, bool value)

      : HIR(node, type),

        value_(value)

    {

    }

    DEFINE_HIR(Boolean);

    bool value() const {

        return value_;

    }

  private:

    bool value_;

};

class HInteger : public HIR

{

  public:

    HInteger(AstNode *node, Type *type, int value)

      : HIR(node, type),

        value_(value)

    {

    }

    DEFINE_HIR(Integer);

    int value() const {

        return value_;

    }

  private:

    int value_;

};

class HString : public HIR

{

  public:

    HString(AstNode *node, Type *type, String *string)

      : HIR(node, type),

        string_(string)

    {

    }

    DEFINE_HIR(String);

    Handle<String> string() const {

        return string_;

    }

  private:

    ScopedRoot<String> string_;

};

class HArray : public HIR

{

  public:

    HArray(AstNode *node, Type *type, Array *array, bool duplicate)

      : HIR(node, type),

        array_(array),

        duplicate_(duplicate)

    {

    }

    DEFINE_HIR(Array);

    Handle<Array> array() const {

        return array_;

    }

    bool duplicate() const {

        return duplicate_;

    }

  private:

    ScopedRoot<Array> array_;

    bool duplicate_;

};

class HConvert : public HIR

{

  public:

    HConvert(AstNode *node, Type *type, Opcode op, HIR *in)

      : HIR(node, type),

        op_(op),

        in_(in)

    {

    }

    DEFINE_HIR(Convert);

    Opcode opcode() const {

        return op_;

    }

    HIR *in() const {

        return in_;

    }

  private:

    Opcode op_;

    HIR *in_;

};

class HLValue : public HIR

{

  public:

    HLValue(AstNode *node, Type *type)

      : HIR(node, type)

    {

    }

    // Pushes a reference to the LValue on the stack.

    virtual void bind(HIRVisitor *visitor, BytecodeEmitter &emitter_) = 0;

    // Duplicates a stack reference.

    virtual void hold(BytecodeEmitter &emitter_) = 0;

    // Reorders the stack for a post-increment operation:

    //   REF VAL -> VAL REF VAL

    virtual void swapAndPick(BytecodeEmitter &emitter_) = 0;

    // Given a stack layout of the form:

    //  [-1]    value

    //  [-2..n] ref

    //

    // Emits a store to the reference.

    virtual void store(BytecodeEmitter &emitter_) = 0;

    virtual void load(BytecodeEmitter &emitter_) = 0;

    // Try to make a direct reference, if semantics allow it. False if the

    // caller must allocate a reference to the stack.

    virtual bool ref(BytecodeEmitter &emitter_) = 0;

    bool isLValue() const {

        return true;

    }

};

class HLocal : public HLValue

{

  public:

    HLocal(AstNode *node, VariableSymbol *sym);

    DEFINE_HIR(Local);

    // Pushes a reference to the LValue on the stack.

    void bind(HIRVisitor *visitor, BytecodeEmitter &emitter_);

    void hold(BytecodeEmitter &emitter_);

    void swapAndPick(BytecodeEmitter &emitter_);

    void store(BytecodeEmitter &emitter_);

    void load(BytecodeEmitter &emitter_);

    bool ref(BytecodeEmitter &emitter_);

    VariableSymbol *sym() const {

        return sym_;

    }

  private:

    VariableSymbol *sym_;

};

class HIndex : public HLValue

{

  public:

    HIndex(AstNode *node, Type *type, HIR *left, HIR *right)

      : HLValue(node, type),

        left_(left),

        right_(right)

    {

    }

    DEFINE_HIR(Index);

    void bind(HIRVisitor *visitor, BytecodeEmitter &emitter_);

    void hold(BytecodeEmitter &emitter_);

    void swapAndPick(BytecodeEmitter &emitter_);

    void store(BytecodeEmitter &emitter_);

    void load(BytecodeEmitter &emitter_);

    bool ref(BytecodeEmitter &emitter_);

    HIR *base() const {

        return left_;

    }

    HIR *index() const {

        return right_;

    }

  private:

    HIR *left_;

    HIR *right_;

};

class HGlobal : public HLValue

{

  public:

    HGlobal(AstNode *node, Symbol *sym)

      : HLValue(node, sym->type()),

        sym_(sym)

    {

    }

    DEFINE_HIR(Global);

    void bind(HIRVisitor *visitor, BytecodeEmitter &emitter_);

    void hold(BytecodeEmitter &emitter_);

    void swapAndPick(BytecodeEmitter &emitter_);

    void store(BytecodeEmitter &emitter_);

    void load(BytecodeEmitter &emitter_);

    bool ref(BytecodeEmitter &emitter_);

    Symbol *sym() const {

        return sym_;

    }

  private:

    Symbol *sym_;

};

class HBinary : public HIR

{

  public:

    HBinary(AstNode *node, Type *type, TokenKind token, HIR *left, HIR *right)

      : HIR(node, type),

        token_(token),

        left_(left),

        right_(right)

    {

    }

    DEFINE_HIR(Binary);

    TokenKind token() const {

        return token_;

    }

    HIR *left() const {

        return left_;

    }

    HIR *right() const {

        return right_;

    }

  private:

    TokenKind token_;

    HIR *left_;

    HIR *right_;

};

class HFloat : public HIR

{

  public:

    HFloat(AstNode *node, Type *type, float value)

      : HIR(node, type),

        value_(value)

    {

    }

    DEFINE_HIR(Float);

    float value() const {

        return value_;

    }

  private:

    float value_;

};

class HUnary : public HIR

{

  public:

    HUnary(AstNode *node, Type *type, TokenKind tok, HIR *in)

      : HIR(node, type),

        in_(in),

        token_(tok)

    {

    }

    DEFINE_HIR(Unary);

    HIR *in() const {

        return in_;

    }

    TokenKind token() const {

        return token_;

    }

  private:

    HIR *in_;

    TokenKind token_;

};

class HStore : public HIR

{

  public:

    HStore(AstNode *node, HLValue *lval, HIR *rval)

      : HIR(node, lval->type()),

        kind_(TOK_ASSIGN),

        lval_(lval),

        rval_(rval)

    {

    }

    HStore(AstNode *node, TokenKind kind, HLValue *lval, HIR *rval)

      : HIR(node, lval->type()),

        kind_(kind),

        lval_(lval),

        rval_(rval)

    {

    }

    DEFINE_HIR(Store);

    HLValue *lval() const {

        return lval_;

    }

    HIR *rval() const {

        return rval_;

    }

    TokenKind kind() const {

        return kind_;

    }

  private:

    TokenKind kind_;

    HLValue *lval_;

    HIR *rval_;

};

class HPostIncDec : public HIR

{

  public:

    HPostIncDec(AstNode *node, TokenKind kind, HLValue *lval, HIR *rval)

      : HIR(node, lval->type()),

        kind_(kind),

        lval_(lval),

        rval_(rval)

    {

    }

    DEFINE_HIR(PostIncDec);

    HLValue *lval() const {

        return lval_;

    }

    HIR *rval() const {

        return rval_;

    }

    TokenKind kind() const {

        return kind_;

    }

  private:

    TokenKind kind_;

    HLValue *lval_;

    HIR *rval_;

};

class HCall : public HIR

{

  public:

    HCall(AstNode *node, Type *type, HIR *callee, HIRList *args)

      : HIR(node, type),

        callee_(callee),

        args_(args)

    {

    }

    DEFINE_HIR(Call);

    HIR *callee() const {

        return callee_;

    }

    HIRList *args() const {

        return args_;

    }

  private:

    HIR *callee_;

    HIRList *args_;

};

class HToRef : public HIR

{

  public:

    HToRef(AstNode *node, Type *type, HIR *in)

      : HIR(node, type),

        in_(in)

    {

    }

    DEFINE_HIR(ToRef);

    HIR *in() const {

        return in_;

    }

  private:

    HIR *in_;

};

class HNewDependentArray : public HIR

{

  public:

    HNewDependentArray(AstNode *node, Type *type, HIR *base, HIR *index)

      : HIR(node, type),

        base_(base),

        index_(index)

    {

    }

    DEFINE_HIR(NewDependentArray);

    HIR *base() const {

        return base_;

    }

    HIR *index() const {

        return index_;

    }

  private:

    HIR *base_;

    HIR *index_;

};

#undef DEFINE_HIR

void EmitHIR(Zone *zone, BytecodeEmitter &emitter, HIR *hir);

}

#endif // _include_sp2_hir_h_