/* 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;

 #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_;

     }

 };

 class Parameter : public PoolObject

 {

     ScopedRoot<String> name_;

     Expression *type_;

     bool reference_;

     bool const_;

     Expression *initializer_;

     VariableSymbol *sym_;

     SourcePosition pos_;

     ExpressionList *dims_;

   public:

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

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

       : name_(name),

         type_(type),

         reference_(reference),

         const_(isConst),

         initializer_(initializer),

         sym_(NULL),

         pos_(pos),

         dims_(dims)

     {

     }

     Expression *type() const {

         return type_;

     }

     Handle<String> name() const {

         return name_;

     }

     bool reference() const {

         return reference_;

     }

     bool isConst() const {

         return const_;

     }

     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

 {

   public:

     BreakStatement(const SourcePosition &pos)

       : Statement(pos)

     {

     }

     DECLARE_NODE(BreakStatement);

 };

 class ContinueStatement : public Statement

 {

   public:

     ContinueStatement(const SourcePosition &pos)

       : Statement(pos)

     {

     }

     DECLARE_NODE(ContinueStatement);

 };

 class Assignment : public Expression

 {

     TokenKind token_;

     Expression *lvalue_;

     Expression *expression_;

   public:

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

       : Expression(pos),

         token_(token),

         lvalue_(left),

         expression_(right)

     {

     }

     DECLARE_NODE(Assignment);

     TokenKind token() const {

         return token_;

     }

     Expression *lvalue() const {

         return lvalue_;

     }

     Expression *expression() const {

         return expression_;

     }

 };

 class ExpressionStatement : public Statement

 {

     Expression *expression_;

   public:

     ExpressionStatement(Expression *expression)

       : Statement(expression->pos()),

         expression_(expression)

     {

     }

     DECLARE_NODE(ExpressionStatement);

     Expression *expression() const {

         return expression_;

     }

 };

 class BlockStatement : public Statement

 {

     StatementList *statements_;

     Scope *scope_;

   public:

     BlockStatement(const SourcePosition &pos, StatementList *statements)

       : Statement(pos),

         statements_(statements),

         scope_(NULL)

     {

     }

     DECLARE_NODE(BlockStatement);

     StatementList *statements() const {

         return statements_;

     }

     Scope *scope() const {

         return scope_;

     }

     void setScope(Scope *scope) {

         scope_ = scope;

     }

 };

 typedef PoolList<Parameter *> ParameterList;

 class FunctionSignature

 {

   public:

     FunctionSignature(Expression *returnType, ParameterList *parameters, bool variadic)

       : returnType_(returnType),

         parameters_(parameters),

         variadic_(variadic)

     {

     }

     Expression *returnType() const {

         return returnType_;

     }

     ParameterList *parameters() const {

         return parameters_;

     }

     bool variadic() const {

         return variadic_;

     }

   private:

     Expression *returnType_;

     ParameterList *parameters_;

     bool variadic_;

 };

 class FunctionTypeStatement : public Statement

 {

   public:

     FunctionTypeStatement(const SourcePosition &pos, Handle<String> name, const FunctionSignature &signature)

       : Statement(pos),

         name_(name),

         signature_(signature)

     {

     }

     DECLARE_NODE(FunctionTypeStatement);

     Handle<String> name() const {

         return name_;

     }

     const FunctionSignature &signature() const {

         return signature_;

     }

   private:

     ScopedRoot<String> name_;

     FunctionSignature signature_;

 };

 class FunctionStatement : public Statement

 {

     ScopedRoot<String> name_;

     TokenKind kind_;

     Statement *body_;

     FunctionSignature signature_;

     bool explicitReturn_;

     FunctionSymbol *sym_;

     Scope *argScope_;

     Scope *varScope_;

   public:

     FunctionStatement(const SourcePosition &pos, Handle<String> name, TokenKind kind,

                       Statement *body, const FunctionSignature &signature, bool explicitReturn)

       : Statement(pos),

         name_(name),

         kind_(kind),

         body_(body),

         signature_(signature),

         explicitReturn_(explicitReturn),

         sym_(NULL),

         argScope_(NULL),

         varScope_(NULL)

     {

     }

     DECLARE_NODE(FunctionStatement);

     Handle<String> name() const {

         return name_;

     }

     Statement *body() const {

         return body_;

     }

     const FunctionSignature &signature() {

         return signature_;

     }

     bool hasExplicitReturn() const {

         return explicitReturn_;

     }

     TokenKind token() const {

         return kind_;

     }

     void setSymbol(FunctionSymbol *sym) {

         assert(!sym_);

         sym_ = sym;

     }

     FunctionSymbol *sym() const {

         return sym_;

     }

     void setScopes(Scope *argScope, Scope *varScope) {

         argScope_ = argScope;

         varScope_ = varScope;

     }

     Scope *argScope() const {

         return argScope_;

     }

     Scope *varScope() const {

         return varScope_;

     }

 };

 class IfStatement : public Statement

 {

     Expression *condition_;

     Statement *ifTrue_;

     Statement *ifFalse_;

   public:

     IfStatement(const SourcePosition &pos, Expression *condition, Statement *ifTrue)

       : Statement(pos),

         condition_(condition),

         ifTrue_(ifTrue),

         ifFalse_(NULL)

     {

     }

     DECLARE_NODE(IfStatement);

     Expression *condition() const {

         return condition_;

     }

     Statement *ifTrue() const {

         return ifTrue_;

     }

     Statement *ifFalse() const {

         return ifFalse_;

     }

     void setIfFalse(Statement *ifFalse) {

         ifFalse_ = ifFalse;

     }

 };

 class EnumStatement : public Statement

 {

     ScopedRoot<String> name_;

     TypeSymbol *sym_;

   public:

     struct Entry {

         ScopedRoot<String> name;

         Expression *expr;

         SourcePosition pos;

         Entry(Handle<String> name, Expression *expr, const SourcePosition &pos)

           : name(name),

             expr(expr),

             pos(pos)

         {

         }

     };

     typedef PoolList<Entry> EntryList;

   public:

     EnumStatement(const SourcePosition &pos, Handle<String> name, EntryList *entries)

       : Statement(pos),

         name_(name),

         sym_(NULL),

         entries_(entries)

     {

     }

     DECLARE_NODE(EnumStatement);

     String *name() const {

         return name_;

     }

     EntryList *entries() const {

         return entries_;

     }

     void setSymbol(TypeSymbol *sym) {

         assert(!sym_);

         sym_ = sym;

     }

     TypeSymbol *sym() const {

         return sym_;

     }

   private:

     EntryList *entries_;

 };

 class IncDecExpression : public Expression

 {

     TokenKind token_;

     Expression *expression_;

     bool postfix_;

   public:

     IncDecExpression(const SourcePosition &pos, TokenKind token, Expression *expression, bool postfix)

       : Expression(pos),

         token_(token),

         expression_(expression),

         postfix_(postfix)

     {

     }

     DECLARE_NODE(IncDecExpression);

     TokenKind token() const {

         return token_;

     }

     Expression *expression() const {

         return expression_;

     }

     bool postfix() const {

         return postfix_;

     }

 };

 class Case : public PoolObject

 {

   public:

     Case(Expression *expression, ExpressionList *others, Statement *statement)

       : expression_(expression),

         others_(others),

         statement_(statement)

     {

     }

     Expression *expression() const {

         return expression_;

     }

     PoolList<Expression *> *others() const {

         return others_;

     }

     Statement *statement() const {

         return statement_;

     }

   private:

     Expression *expression_;

     PoolList <Expression *> *others_;

     Statement *statement_;

 };

 struct CaseValue

 {

     BoxedPrimitive box;

     size_t statement;

     CaseValue(size_t statement)

       : statement(statement)

     {

     }

 };

 typedef PoolList<CaseValue> CaseValueList;

 class SwitchStatement : public Statement

 {

   public:

     SwitchStatement(const SourcePosition &pos, Expression *expression, PoolList<Case *> *cases,

                     Statement *def)

       : Statement(pos),

         expression_(expression),

         cases_(cases),

         default_(def),

         table_(NULL)

     {

     }

     DECLARE_NODE(SwitchStatement);

     Expression *expression() const {

         return expression_;

     }

     PoolList<Case *> *cases() const {

         return cases_;

     }

     Statement *defaultCase() const {

         return default_;

     }

     void setCaseValueList(CaseValueList *list) {

         table_ = list;

     }

     CaseValueList *caseValueList() const {

         return table_;

     }

   private:

     Expression *expression_;

     PoolList<Case *> *cases_;

     Statement *default_;

     CaseValueList *table_;

 };

 class StructureStatement : public Statement

 {

   public:

     class Field : public PoolObject

     {

         SourcePosition pos_;

         Expression *type_;

         ScopedRoot<String> name_;

       public:

         Field(const SourcePosition &pos,

               Expression *type,

               Handle<String> name)

           : pos_(pos),