/*

  * 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

     };

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

     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_