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

 *

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

#define _include_name_binding_h_

#include "PoolAllocator.h"

#include "Types.h"

#include "Scanner.h"

namespace ke {

class Variable;

class NamedFunction;

class Scope;

class Type;

class NamedConstant;

class NamedType;

class UnboundName;

class String;

class BoundName : public PoolObject

{

    Scope *scope_;

    ScopedRoot<String> name_;

    ScopedRoot<Type> type_;

    bool used_;

  protected:

    SourcePosition pos_;

  public:

    enum Kind {

      VARIABLE,

      FUNCTION,

      CONSTANT,

      TYPE,

      UNBOUND

    };

    BoundName(Scope *scope, Handle<String> name, const SourcePosition &pos);

    virtual Kind kind() const = 0;

    String *name() const {

        return name_;

    }

    Scope *scope() const {

        return scope_;

    }

    Variable *toVariable() {

        assert(kind() == VARIABLE);

        return reinterpret_cast<Variable *>(this);

    }

    NamedFunction *toNamedFunction() {

        assert(kind() == FUNCTION);

        return reinterpret_cast<NamedFunction *>(this);

    }

    NamedConstant *toNamedConstant() {

        assert(kind() == CONSTANT);

        return reinterpret_cast<NamedConstant *>(this);

    }

    NamedType *toNamedType() {

        assert(kind() == TYPE);

        return reinterpret_cast<NamedType *>(this);

    }

    Type *type() const {

        return type_;

    }

    void setType(Handle<Type> type) {

        type_ = type;

    }

    void setUsed() {

        used_ = true;

    }

    bool used() const {

        return used_;

    }

    const SourcePosition &pos() {

        return pos_;

    }

};

class NamedFunction : public BoundName

{

    unsigned slot_;

    TokenKind token_;

    ScopedRoot<Type> forwardType_;

    bool isVariadicNative_;

    Vector<BoundName *, PoolAllocationPolicy> globals_;

  public:

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

    Kind kind() const {

        return FUNCTION;

    }

    void allocate(unsigned slot) {

        slot_ = slot;

    }

    bool isForward() const {

        return token_ == TOK_FORWARD;

    }

    bool isPublic() const {

        return token_ == TOK_PUBLIC;

    }

    bool isNative() const {

        return token_ == TOK_NATIVE;

    }

    void setForwardType(Handle<Type> type) {

        forwardType_ = type;

    }

    Type *forwardType() {

        return forwardType_;

    }

    void setImplemented(const SourcePosition &at) {

        token_ = TOK_PUBLIC;

        pos_ = at;

    }

    void markNativeVariadic() {

        assert(token_ == TOK_NATIVE);

        isVariadicNative_ = true;

    }

    bool isNativeVariadic() {

        assert(token_ == TOK_NATIVE);

        return isVariadicNative_;

    }

    unsigned slot() const {

        return slot_;

    }

    bool addUsedGlobal(BoundName *name) {

        return globals_.append(name);

    }

    Vector<BoundName *, PoolAllocationPolicy> *usedGlobals() {

        return &globals_;

    }

};

class NamedConstant : public BoundName

{

    BoxedPrimitive value_;

    Type *type_;

  public:

    NamedConstant(Scope *scope, Handle<String> name, const SourcePosition &pos)

      : BoundName(scope, name, pos),

        type_(NULL)

    {

    }

    Kind kind() const {

        return CONSTANT;

    }

    void set(Type *type, const BoxedPrimitive &value) {

        value_ = value;

        type_ = type;

    }

    Type *type() const {

        return type_;

    }

    BoxedPrimitive value() const {

        return value_;

    }

};

class NamedType : public BoundName

{

  public:

    NamedType(Scope *scope, Handle<String> name, Handle<Type> type)

      : BoundName(scope, name, SourcePosition())

    {

        setType(type);

    }

    NamedType(Scope *scope, Handle<String> name, const SourcePosition &pos)

      : BoundName(scope, name, pos)

    {

    }

    Kind kind() const {

        return TYPE;

    }

};

class UnboundName : public BoundName

{

  public:

    UnboundName(Scope *scope, Handle<String> name)

      : BoundName(scope, name, SourcePosition())

    {

    }

    Kind kind() const {

        return UNBOUND;

    }

};

class Variable : public BoundName

{

  public:

    enum Location {

        UNALLOCATED,

        STACK,

        PARAMETER,

        ENVIRONMENT

    };

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

    Kind kind() const {

        return VARIABLE;

    }

    bool unallocated() const {

        return location() == UNALLOCATED;

    }

    void allocate(Location location, unsigned slot) {

        location_ = location;

        slot_ = slot;

    }

    Location location() const {

        return location_;

    }

    unsigned slot() const {

        assert(!unallocated());

        return slot_;

    }

    bool needsHeapAllocation();

  private:

    Location location_;

    unsigned slot_;

};

}

#endif // _include_name_binding_h_