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

 *

 * Copyright (C) 2012 David Anderson

 *

 * This file is part of JITCraft.

 *

 * JITCraft 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.

 * 

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

 * JITCraft. If not, see http://www.gnu.org/licenses/.

 */

#ifndef _include_semantic_analysis_h_

#define _include_semantic_analysis_h_

#include <assert.h>

#include "AST.h"

#include "Types.h"

namespace ke {

class Box;

class SemanticAnalysis : public AstVisitor

{

    Zone *zone_;

    CompileContext &cc_;

    ParseTree *tree_;

    Scope *scope_;

    NamedFunction *function_;

    enum ReturnStatus

    {

        Returns_Never,

        Returns_Sometimes,

        Returns_Always

    };

    // Tuple that describes whether a path terminates control flow, and

    // if it is guaranteed to end in a return.

    class ControlStatus

    {

        bool terminates_;

        ReturnStatus returns_;

      public:

        ControlStatus(bool terminates, ReturnStatus returns)

          : terminates_(terminates),

            returns_(returns)

        {

        }

        bool terminates() const {

            return terminates_;

        }

        ReturnStatus returns() const {

            return returns_;

        }

    };

    // Used to keep track of terminating control flow and return statements

    // inside control structures.

    class ControlScope

    {

        ReturnStatus returns_;

        ControlScope **prevp_;

        ControlScope *prev_;

        bool terminates_;

      public:

        ControlScope(ControlScope **prev)

          : returns_(Returns_Never),

            prevp_(prev),

            prev_(*prev),

            terminates_(false)

        {

            *prevp_ = this;

        }

        ControlStatus status() const {

            return ControlStatus(terminates_, returns_);

        }

        // We allow multiple terminators, but only the first one takes effect.

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

        // unreachable.

        void returns(ReturnStatus status) {

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

        ~ControlScope()

        {

            *prevp_ = prev_;

        }

    };

    class LoopScope

    {

        LoopScope **prevp_;

        LoopScope *prev_;

        unsigned breaks_;

        unsigned continues_;

      public:

        LoopScope(LoopScope **prev)

          : prevp_(prev),

            prev_(*prev),

            breaks_(0),

            continues_(0)

        {

            *prevp_ = this;

        }

        ~LoopScope()

        {

            *prevp_ = prev_;

        }

        void addBreak() {

            breaks_++;

        }

        void addContinue() {

            continues_++;

        }

        unsigned breaks() const {

            return breaks_;

        }

        unsigned continues() const {

            return continues_;

        }

    };

    ControlScope *control_;

    LoopScope *loop_;

  private:

    bool canTest(AstNode *node, Handle<Type> type);

    void typeMismatch(const SourcePosition &pos, Handle<Type> actual, Handle<Type> given);

    void unaryTypeError(AstNode *node, TokenKind token, Handle<Type> type);

    void binaryTypeError(AstNode *node, TokenKind token, Handle<Type> left, Handle<Type> right);

    Type *typeCheckBinary(AstNode *node, TokenKind token, Handle<Type> left, Handle<Type> right);

    Type *bindType(const SourcePosition &pos, BoundName *name);

    // These check if one type is compatible with another type, for various

    // purposes, like:

    //      return (expr) matches function return type

    //      call(a, b)    matches expected arg type

    //      a = b         matches declared type

    //

    bool typeCheckArrayAssignment(const SourcePosition &pos, Handle<Type> given, Handle<Type> actual, bool forAssign);

    bool typeCheckAssignment(const SourcePosition &pos, Handle<Type> given, Handle<Type> actual, bool forAssign);

    bool typeCheckParameter(AstNode *node, Handle<Type> given, Handle<Type> actual);

    Type *visitForLoad(Expression *expression);

    bool preanalyze(FunctionStatement *node);

    Type *visitForLValue(Expression *expression);

    Type *visitAndApplyType(Expression *expression);

    ControlStatus visitForControl(Statement *statement);

    bool evaluateDimensions(ExpressionList *exprs, int dims[MAX_ARRAY_DEPTH]);

    bool inferFixedArrayLiteral(ArrayLiteral *literal,

                                Handle<Type> type,

                                int dims[MAX_ARRAY_DEPTH],

                                unsigned dimcount,

                                unsigned level);

    // Builds an array type used for parameters, returns, or field entries.

    Type *buildArrayType(Handle<Type> type, ExpressionList *dimensions, bool isConst);

    Box *evaluateDefaultParameter(Handle<Type> type, Parameter *parameter);

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

    bool buildFunctionArgs(AstNode *node, TokenKind kind, const FunctionSignature &sig,

                           FixedArray **args, FixedArray **defaults);

    void markCallResultUsed(CallExpression *call);

    bool determineLiveFunctions();

  public:

    SemanticAnalysis(Zone *zone, CompileContext &cc, ParseTree *tree);

    bool analyze();

  public:

    void visit(NameProxy *name);

    void visit(Assignment *node);

    void visit(BinaryExpression *node);

    void visit(ReturnStatement *node);

    void visit(ForStatement *node);

    void visit(BlockStatement *node);

    void visit(VariableDeclaration *node);

    void visit(IntegerLiteral *node);

    void visit(ExpressionStatement *node);

    void visit(FunctionStatement *node);

    void visit(CallExpression *node);

    void visit(IfStatement *node);

    void visit(IndexExpression *node);

    void visit(EnumStatement *node);

    void visit(FloatLiteral *node);

    void visit(WhileStatement *node);

    void visit(BreakStatement *node);

    void visit(ContinueStatement *node);

    void visit(StringLiteral *node);

    void visit(IncDecExpression *node);

    void visit(UnaryExpression *node);

    void visit(TernaryExpression *node);

    void visit(BooleanLiteral *node);

    void visit(StructureStatement *node);

    void visit(FieldExpression *node);

    void visit(SwitchStatement *node);

    void visit(FunctionTypeStatement *node);

    void visit(ArrayLiteral *node);

};

const char *GetTypeName(Type *type);

} // namespace ke

#endif // _include_semantic_analysis_h_