/*

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

#define _include_jitcraft_scopes_h_

#include "PoolAllocator.h"

#include "AST.h"

#include "NameBinding.h"

#include "Structures.h"

namespace ke {

class CompileContext;

class EnvironmentMap;

class Scope : public PoolObject

{

    PoolAllocator &pool_;

    PoolList<BoundName *> names_;

    PoolList<Scope *> children_;

    PoolList<Variable *> parameters_;

    unsigned locals_;

    unsigned maxContainedLocals_;

    unsigned numFunctions_;

    unsigned numNatives_;

    PoolList<Variable *> envVars_;

    Variable *lifoSlot_;

    bool empty() const {

        return names_.length() == 0;

    }

    void unlink();

  public:

    enum Kind {

        GLOBAL,

        FUNCTION,

        BLOCK

    };

  public:

    Scope(PoolAllocator &pool, Kind kind, Scope *enclosing);

    bool initialize();

    Kind kind() const {

        return kind_;

    }

    Scope *enclosing() const {

        return enclosing_;

    }

    unsigned locals() const {

        return locals_;

    }

    unsigned maxContainedLocals() const {

        return maxContainedLocals_;

    }

    unsigned numFunctions() const {

        return numFunctions_;

    }

    unsigned numNatives() const {

        return numNatives_;

    }

    unsigned numArguments() const {

        return parameters_.length();

    }

    unsigned numEnvironmentVars() const {

        return envVars_.length();

    }

    Variable *getArgument(size_t index) {

        return parameters_[index];

    }

    Variable *lifoSlot() {

        return lifoSlot_;

    }

    void setUsesLifoHeap();

    Scope *unlinkIfEmpty();

    BoundName *localLookup(Handle<String> name);

    BoundName *lookup(Handle<String> name);

    NamedFunction *declareFunction(Handle<String> name, const SourcePosition &pos, TokenKind token);

    Variable *declareVariable(Handle<String> name, const SourcePosition &pos);

    Variable *declareArgument(Handle<String> name, const SourcePosition &pos);

    NamedConstant *declareConstant(Handle<String> name, const SourcePosition &pos);

    NamedType *declareType(Handle<String> name, const SourcePosition &pos);

    NamedType *declareType(Handle<String> name, Handle<Type> type);

    EnvironmentMap *createEnvironmentMap(Zone *zone);

    void allocate(Variable *var);

    void allocate();

    void allocateGlobals();

  public:

    static bool Bind(CompileContext &cc, ParseTree *tree);

    static void Allocate(ParseTree *tree);

  private:

    Kind kind_;

    Scope *enclosing_;

};

}

#endif // _include_jitcraft_scopes_h_