/*

 * 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 visitEnumStatement(EnumStatement *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 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

    };

    // For a given control flow path, whether it returns.

    enum ReturnStatus

    {

        Returns_Never,

        Returns_Sometimes,

        Returns_Always

    };

    // For a given control flow path, whether it terminates,

    // and if it terminates, whether it returns.

    class ControlStatus

    {

        bool terminates_;

        ReturnStatus returns_;

      public:

        ControlStatus()

        {

        }

        ControlStatus(bool terminates, ReturnStatus returns)

          : terminates_(terminates),

            returns_(returns)

        {

        }

        bool terminates() const {

            return terminates_;

        }

        ReturnStatus returns() const {

            return returns_;

        }

    };

    class ControlScope

    {

        ReturnStatus returns_;

        ControlScope **prevp_;

        ControlScope *prev_;

        bool terminates_;

      public:

        ControlScope(ControlScope **prevp)

          : returns_(Returns_Never),

            prevp_(prevp),

            prev_(*prevp),

            terminates_(false)

        {

            *prevp_ = this;

        }

        ~ControlScope() {

            *prevp_ = prev_;

        }

        ControlStatus status() {

            return ControlStatus(terminates_, returns_);

        }

        void returns(ReturnStatus status) {

            // We allow multiple terminates, but only the first one takes

            // effect. For example, |break; continue;| is legal, but the

            // continue is unreachable.

            if (terminates_)

                return;

            if (status > returns_)

                returns_ = status;

        }

        void terminate(ReturnStatus status) {

            if (terminates_)

                return;

            terminates_ = true;

            returns_ = status;

        }

        void merge(const ControlStatus &left, const ControlStatus &right);

        void inherit(const ControlStatus &other);

    };

    void requireLifoStack();

    ControlStatus visitForControl(Statement *statement);

    ControlStatus 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);

    HIR *typeFailure(const SourcePosition &pos, Handle<Type> from, Handle<Type> to);

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

        bool breaks_;

      public:

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

                  LoopScope **prevp)

          : scope_(scope),

            bk_(bk),

            ct_(ct),

            prevp_(prevp),

            prev_(*prevp),

            usesLifoStack_(false),

            breaks_(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_;

        }

        void setBreaks() {

            breaks_ = true;

        }

        bool breaks() const {

            return breaks_;

        }

    };

  private:

    Zone *zone_;

    PoolAllocator &pool_;

    CompileContext &cc_;

    TranslationUnit *unit_;

    HIR *hir_;

    Scope *scope_;

    BytecodeEmitter emitter_;

    ScopedRoot<Module> module_;

    ScopedRoot<FunctionType> fun_;

    LoopScope *loop_;

    ControlScope *control_;

};

} // namespace ke

#endif // _include_sp2_sema_h_