/* vim: set ts=4 sw=4 tw=99 et:

 *

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

#define _include_sourcepawn_ast_h_

#include "../PoolAllocator.h"

#include "../Vector.h"

#include "Token.h"

#include "NameBinding.h"

#include "Symbols.h"

namespace ke {

class Scope;

struct PathComponent;

#define ASTKINDS(_)             \

    _(VariableDeclaration)      \

    _(ForStatement)             \

    _(ReturnStatement)          \

    _(IntegerLiteral)           \

    _(FloatLiteral)             \

    _(StringLiteral)            \

    _(BinaryExpression)         \

    _(BlockStatement)           \

    _(Assignment)               \

    _(NameProxy)                \

    _(ExpressionStatement)      \

    _(FunctionStatement)        \

    _(CallExpression)           \

    _(IfStatement)              \

    _(IndexExpression)          \

    _(FieldExpression)          \

    _(EnumStatement)            \

    _(WhileStatement)           \

    _(BreakStatement)           \

    _(ContinueStatement)        \

    _(FunctionTypeStatement)    \

    _(IncDecExpression)         \

    _(UnaryExpression)          \

    _(TernaryExpression)        \

    _(BooleanLiteral)           \

    _(StructureStatement)       \

    _(SwitchStatement)          \

    _(ArrayLiteral)             \

    _(ImportStatement)

// Forward declarations.

#define _(name) class name;

ASTKINDS(_)

#undef _

class AstVisitor;

// Interface for AST nodes.

class AstNode : public PoolObject

{

    SourcePosition pos_;

  public:

    enum Kind {

#       define _(name) k##name,

        ASTKINDS(_)

#       undef _

        AstKind_Invalid

    };

    AstNode(const SourcePosition &pos)

      : pos_(pos)

    {

    }

    virtual Kind kind() const = 0;

#define _(name)     bool is##name() { return kind() == k##name; }                   \

                    name *to##name() { assert(is##name()); return (name *)this; }   \

                    name *as##name() { if (!is##name()) return NULL; return to##name(); }

    ASTKINDS(_)

#undef _

    virtual void accept(AstVisitor *visitor) = 0;

    const SourcePosition &pos() const {

        return pos_;

    }

};

#define DECLARE_NODE(type)                      \

    Kind kind() const {                         \

        return k##type;                         \

    }                                           \

    void accept(AstVisitor *visitor) {          \

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

    }

class AstVisitor

{

  public:

#define _(name) virtual void visit##name(name *node) { assert(false); }

    ASTKINDS(_)

#undef _

};

class Statement : public AstNode

{

  public:

    Statement(const SourcePosition &pos)

      : AstNode(pos)

    {

    }

};

class Expression : public AstNode

{

    ScopedRoot<Type> type_;

  public:

    Expression(const SourcePosition &pos)

      : AstNode(pos),

        type_(NULL)

    {

    }

    void setType(Type *type) {

        type_ = type;

    }

    Type *type() const {

        return type_;

    }

};

typedef PoolList<Statement *> StatementList;

typedef PoolList<Expression *> ExpressionList;

class VariableDeclaration : public Statement

{

    TypeQualifiers qual_;

    ScopedRoot<String> name_;

    Expression *initialization_;

    ExpressionList *dims_;

    Expression *type_;

    VariableSymbol *sym_;

  public:

    VariableDeclaration(const SourcePosition &pos, TypeQualifiers qual, Handle<String> name,

                        Expression *type, ExpressionList *dims, Expression *initialization)

      : Statement(pos),

        qual_(qual),

        name_(name),

        initialization_(initialization),

        dims_(dims),

        type_(type),

        sym_(NULL)

    {

    }

    DECLARE_NODE(VariableDeclaration);

    Expression *initialization() const {

        return initialization_;

    }

    Handle<String> name() {

        return name_;

    }

    Expression *declType() const {

        return type_;

    }

    void setSymbol(VariableSymbol *sym) {

        assert(!sym_);

        sym_ = sym;

    }

    VariableSymbol *sym() const {

        return sym_;

    }

    Expression *type() const {

        return type_;

    }

    ExpressionList *dims() const {

        return dims_;

    }

    TypeQualifiers quals() const {

        return qual_;

    }

};

class Parameter : public PoolObject

{

    ScopedRoot<String> name_;

    Expression *type_;

    bool reference_;

    Expression *initializer_;

    VariableSymbol *sym_;

    SourcePosition pos_;

    ExpressionList *dims_;

    TypeQualifiers quals_;

  public:

    Parameter(Handle<String> name, Expression *type, bool reference, TypeQualifiers quals,

              ExpressionList *dims, Expression *initializer, const SourcePosition &pos)

      : name_(name),

        type_(type),

        reference_(reference),

        initializer_(initializer),

        sym_(NULL),

        pos_(pos),

        dims_(dims),

        quals_(quals)

    {

    }

    Expression *type() const {

        return type_;

    }

    Handle<String> name() const {

        return name_;

    }

    bool reference() const {

        return reference_;

    }

    TypeQualifiers quals() const {

        return quals_;

    }

    ExpressionList *dims() const {

        return dims_;

    }

    Expression *initializer() const {

        return initializer_;

    }

    void setSymbol(VariableSymbol *sym) {

        assert(!sym_);

        sym_ = sym;

    }

    VariableSymbol *sym() const {

        return sym_;

    }

    const SourcePosition &pos() const {

        return pos_;

    }

};

class NameProxy : public Expression

{

    ScopedRoot<String> name_;

    Symbol *binding_;

  public:

    NameProxy(const SourcePosition &pos, Handle<String> name)

      : Expression(pos),

        name_(name),

        binding_(NULL)

    {

    }

    DECLARE_NODE(NameProxy);

    Handle<String> name() const {

        return name_;

    }

    Symbol *sym() const {

        return binding_;

    }

    void bind(Symbol *sym) {

        binding_ = sym;

    }

};

class BooleanLiteral : public Expression

{

    TokenKind token_;

  public:

    BooleanLiteral(const SourcePosition &pos, TokenKind token)

      : Expression(pos),

        token_(token)

    {

    }

    DECLARE_NODE(BooleanLiteral);

    TokenKind token() const {

        return token_;

    }

};

class IntegerLiteral : public Expression

{

    int value_;

  public:

    IntegerLiteral(const SourcePosition &pos, int value)

      : Expression(pos),

        value_(value)

    {

    }

    DECLARE_NODE(IntegerLiteral);

    int value() const {

        return value_;

    }

};

class FloatLiteral : public Expression

{

    double value_;

  public:

    FloatLiteral(const SourcePosition &pos, double value)

      : Expression(pos),

        value_(value)

    {

    }

    DECLARE_NODE(FloatLiteral);

    double value() const {

        return value_;

    }

};

class StringLiteral : public Expression

{

    ScopedRoot<String> string_;

  public:

    StringLiteral(const SourcePosition &pos, String *string)

      : Expression(pos),

        string_(string)

    {

    }

    DECLARE_NODE(StringLiteral);

    String *string() const {

        return string_;

    }

};

class ArrayLiteral : public Expression

{

    TokenKind token_;

    ExpressionList *expressions_;

  public:

    ArrayLiteral(const SourcePosition &pos, TokenKind token, ExpressionList *expressions)

      : Expression(pos),

        token_(token),

        expressions_(expressions)

    {

    }

    DECLARE_NODE(ArrayLiteral);

    TokenKind token() const {

        return token_;

    }

    ExpressionList *expressions() const {

        return expressions_;

    }

    bool isFixed() const {

        return token_ == TOK_LBRACE;

    }

};

class UnaryExpression : public Expression

{

    Expression *expression_;

    TokenKind token_;

    NameProxy *tag_;

  public:

    UnaryExpression(const SourcePosition &pos, TokenKind token, Expression *expr)

      : Expression(pos),

        expression_(expr),

        token_(token),

        tag_(NULL)

    {

    }

    UnaryExpression(const SourcePosition &pos, TokenKind token, Expression *expr,

                    NameProxy *tag)

      : Expression(pos),

        expression_(expr),

        token_(token),

        tag_(tag)

    {

    }

    DECLARE_NODE(UnaryExpression);

    Expression *expression() const {

        return expression_;

    }

    TokenKind token() const {

        return token_;

    }

    NameProxy *tag() const {

        return tag_;

    }

};

class BinaryExpression : public Expression

{

    Expression *left_;

    Expression *right_;

    TokenKind token_;

  public:

    BinaryExpression(const SourcePosition &pos, TokenKind token, Expression *left, Expression *right)

      : Expression(pos),

        left_(left),

        right_(right),

        token_(token)

    {

    }

    DECLARE_NODE(BinaryExpression);

    Expression *left() const {

        return left_;

    }

    Expression *right() const {

        return right_;

    }

    TokenKind token() const {

        return token_;

    }

};

class TernaryExpression : public Expression

{

    Expression *condition_;

    Expression *left_;

    Expression *right_;

  public:

    TernaryExpression(const SourcePosition &pos, Expression *condition, Expression *left, Expression *right)

      : Expression(pos),

        condition_(condition),

        left_(left),

        right_(right)

    {

    }

    DECLARE_NODE(TernaryExpression);

    Expression *condition() const {

        return condition_;

    }

    Expression *left() const {

        return left_;

    }

    Expression *right() const {

        return right_;

    }

};

class IndexExpression : public Expression

{

    Expression *left_;

    Expression *right_;

  public:

    IndexExpression(const SourcePosition &pos, Expression *left, Expression *right)

      : Expression(pos),

        left_(left),

        right_(right)

    {

    }

    DECLARE_NODE(IndexExpression);

    Expression *left() const {

        return left_;

    }

    Expression *right() const {

        return right_;

    }

};

class FieldExpression : public Expression

{

    Expression *left_;

    ScopedRoot<String> field_;

    unsigned fieldIndex_;

  public:

    FieldExpression(const SourcePosition &pos, Expression *left, Handle<String> field)

      : Expression(pos),

        left_(left),

        field_(field),

        fieldIndex_(unsigned(-1))

    {

    }

    DECLARE_NODE(FieldExpression);

    Expression *left() const {

        return left_;

    }

    String *field() const {

        return field_;

    }

    void setFieldIndex(unsigned index) {

        assert(fieldIndex_ == unsigned(-1));

        fieldIndex_ = index;

    }

    unsigned fieldIndex() const {

        assert(fieldIndex_ != unsigned(-1));

        return fieldIndex_;

    }

};

class CallExpression : public Expression

{

    Expression *callee_;

    ExpressionList *arguments_;

  public:

    CallExpression(const SourcePosition &pos, Expression *callee, ExpressionList *arguments)

      : Expression(pos),

        callee_(callee),

        arguments_(arguments)

    {

    }

    DECLARE_NODE(CallExpression);

    Expression *callee() const {

        return callee_;

    }

    ExpressionList *arguments() const {

        return arguments_;

    }

};

class ForStatement : public Statement

{

    Statement *initialization_;

    Expression *condition_;

    Statement *update_;

    Statement *body_;

    Scope *scope_;

  public:

    ForStatement(const SourcePosition &pos, Statement *initialization,

                 Expression *condition, Statement *update, Statement *body)

      : Statement(pos),

        initialization_(initialization),

        condition_(condition),

        update_(update),

        body_(body),

        scope_(NULL)

    {

    }

    DECLARE_NODE(ForStatement);

    Statement *initialization() const {

        return initialization_;

    }

    Expression *condition() const {

        return condition_;

    }

    Statement *update() const {

        return update_;

    }

    Statement *body() const {

        return body_;

    }

    Scope *scope() const {

        return scope_;

    }

    void setScope(Scope *scope) {

        scope_ = scope;

    }

};

class WhileStatement : public Statement

{

    TokenKind token_;

    Expression *condition_;

    Statement *body_;

  public:

    WhileStatement(const SourcePosition &pos, TokenKind kind, Expression *condition, Statement *body)

      : Statement(pos),

        token_(kind),

        condition_(condition),

        body_(body)

    {

    }

    DECLARE_NODE(WhileStatement);

    TokenKind token() const {

        return token_;

    }

    Expression *condition() const {

        return condition_;

    }

    Statement *body() const {

        return body_;

    }

};

class ReturnStatement : public Statement

{

    Expression *expression_;

  public:

    ReturnStatement(const SourcePosition &pos, Expression *expression)

      : Statement(pos),

        expression_(expression)

    {

    }

    DECLARE_NODE(ReturnStatement);

    Expression *expression() const {

        return expression_;

    }

};

class BreakStatement : public Statement