/*

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

#define _include_sp2_sema_h_

#include "AST.h"

#include "HIR.h"

#include "Scopes.h"

#include "BytecodeEmitter.h"

namespace ke {

// Semantic analysis occurs after all names and types have been bound. It

// performs the important task of validating the semantics and type safety

// of a parse tree.

// 

// The semantic analysis phase also produces bytecode. This occurs on a

// statement-by-statement basis. The result of analyzing an expression is a

// tree of operations which is then flattened.

class SemanticAnalysis : public AstVisitor

{

  public:

    SemanticAnalysis(Zone *zone, CompileContext &cc, TranslationUnit *unit);

    void analyze();

  private:

    SemanticAnalysis(SemanticAnalysis *parent, Handle<FunctionType> fun);

    Function *compile(FunctionStatement *stmt);

  public:

    void visitFunctionStatement(FunctionStatement *node);

    void visitBlockStatement(BlockStatement *node);

    void visitExpressionStatement(ExpressionStatement *node);

    void visitReturnStatement(ReturnStatement *node);

    void visitCallExpression(CallExpression *node);

    void visitNameProxy(NameProxy *name);

    void visitIntegerLiteral(IntegerLiteral *node);

    void visitFloatLiteral(FloatLiteral *node);

    void visitVariableDeclaration(VariableDeclaration *node);

    void visitForStatement(ForStatement *node);

    void visitWhileStatement(WhileStatement *node);

    void visitAssignment(Assignment *node);

    void visitBinaryExpression(BinaryExpression *node);

    void visitBreakStatement(BreakStatement *node);

    void visitContinueStatement(ContinueStatement *node);

    void visitIfStatement(IfStatement *node);

    void visitIndexExpression(IndexExpression *node);

    void visitIncDecExpression(IncDecExpression *node);

#if 0

    void visitFunctionTypeStatement(FunctionTypeStatement *node);

    void visitImportStatement(ImportStatement *node);

    void visitEnumStatement(EnumStatement *node);

    void visitStructureStatement(StructureStatement *node);

    void visitSwitchStatement(SwitchStatement *node);

    void visitStringLiteral(StringLiteral *node);

    void visitUnaryExpression(UnaryExpression *node);

    void visitTernaryExpression(TernaryExpression *node);

    void visitBooleanLiteral(BooleanLiteral *node);

    void visitFieldExpression(FieldExpression *node);

    void visitArrayLiteral(ArrayLiteral *node);

#endif

  private:

    bool checkArgumentCount(Handle<FunctionType> type, unsigned actual);

  private:

    enum CoercionKind {

        Coerce_Arg,

        Coerce_Return,

        Coerce_Assign

    };

    void requireLifoStack();

    void visitLoopBody(Statement *stmt);

    void visitForTest(Expression *expr,

                      BytecodeEmitter::Label *trueBranch,

                      BytecodeEmitter::Label *falseBranch,

                      BytecodeEmitter::Label *fallthrough);

    void set(VariableSymbol *sym);

    HIR *eval(Expression *expr);

    HIR *binary(AstNode *node, TokenKind token, HIR *left, HIR *right);

    HIR *coerce(HIR *from, Handle<Type> to, CoercionKind kind);

    Type *coercionType(TokenKind token, HIR *left, HIR *right);

    HLValue *lvalue(Expression *expr);

    void discharge(HIR *hir);

    bool typeCheckArray(const SourcePosition &pos,

                        Handle<Type> argGiven,

                        Handle<Type> argActual,

                        CoercionKind kind);

  private:

    // Used to target break/catch statements.

    class LoopScope

    {

        Scope *scope_;

        BytecodeEmitter::Label *bk_;

        BytecodeEmitter::Label *ct_;

        LoopScope **prevp_;

        LoopScope *prev_;

        bool usesLifoStack_;

      public:

        LoopScope(Scope *scope, BytecodeEmitter::Label *bk, BytecodeEmitter::Label *ct,

                  LoopScope **prevp)

          : scope_(scope),

            bk_(bk),

            ct_(ct),

            prevp_(prevp),

            prev_(*prevp),

            usesLifoStack_(false)

        {

            *prevp_ = this;

        }

        ~LoopScope()

        {

            *prevp_ = prev_;

        }

        BytecodeEmitter::Label *break_() {

            return bk_;

        }

        BytecodeEmitter::Label *continue_() {

            return ct_;

        }

        Scope *scope() {

            return scope_;

        }

        void setUsesLifoStack() {

            usesLifoStack_ = true;

        }

        bool usesLifoStack() const {

            return usesLifoStack_;

        }

    };

  private:

    Zone *zone_;

    PoolAllocator &pool_;

    CompileContext &cc_;

    TranslationUnit *unit_;

    HIR *hir_;

    Scope *scope_;

    BytecodeEmitter emitter_;

    ScopedRoot<Module> module_;

    ScopedRoot<FunctionType> fun_;

    LoopScope *loop_;

};

} // namespace ke

#endif // _include_sp2_sema_h_