/* 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_sp2_symbol_h_

#define _include_sp2_symbol_h_

#include "../PoolAllocator.h"

#include "../Handles.h"

#include "../Opcodes.h"

#include "../Types.h"

#include "../Strings.h"

namespace ke {

class String;

#define SYMBOL_KINDS(_) \

    /* Any kind of variable or argument produces a VariableSymbol. */ \

    _(Variable)         \

    /* A function declaration produces a FunctionSymbol. */ \

    _(Function)         \

    /* A named constant produces a ConstantSymbol. */ \

    _(Constant)         \

    /* A named type (class struct, typedef, etc) produces a TypeSymbol. */ \

    _(Type)             \

    /* An import name. */ \

    _(Import)           \

    /* A name implicitly derived from an import. */ \

    _(Implicit)

#define _(name)     class name##Symbol;

SYMBOL_KINDS(_)

#undef _

class Scope;

// A symbol represents the declaration of a named entity.

class Symbol : public PoolObject

{

  public:

    enum Kind {

#       define _(name) k##name,

        SYMBOL_KINDS(_)

#       undef _

        kTotalSymbolKinds

    };

  public:

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

      : scope_(scope),

        name_(name),

        pos_(pos)

    {

    }

    virtual Kind kind() const = 0;

    Handle<String> name() const {

        return name_;

    }

    const SourcePosition &pos() const {

        return pos_;

    }

    Handle<Type> type() const {

        return type_;

    }

    Scope *scope() const {

        return scope_;

    }

  public:

#define _(name)                                             \

    bool is##name() const {                                 \

        return (kind() == k##name);                         \

    }                                                       \

    name##Symbol *as##name() {                              \

        if (is##name())                                     \

            return to##name();                              \

        return NULL;                                        \

    }                                                       \

    name##Symbol *to##name() {                              \

        assert(is##name());                                 \

        return reinterpret_cast<name##Symbol *>(this);      \

    }

    SYMBOL_KINDS(_)

#undef _

  private:

    Scope *scope_;

    ScopedRoot<String> name_;

    SourcePosition pos_;

  protected:

    ScopedRoot<Type> type_;

};

class VariableSymbol : public Symbol

{

  public:

    enum Storage {

        Unknown,

        Local,

        Arg,

        Heap

    };

  public:

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

      : Symbol(scope, name, pos),

        storage_(Unknown)

    {

    }

    VariableSymbol(Scope *scope, Handle<String> name, const SourcePosition &pos, Handle<Type> type)

      : Symbol(scope, name, pos),

        storage_(Unknown)

    {

        type_ = type;

    }

    Kind kind() const {

        return kVariable;

    }

    void setType(Type *type) {

        assert(!type_);

        type_ = type;

    }

    void allocate(Storage storage, unsigned slot) {

        storage_ = storage;

        slot_ = slot;

    }

    Storage storage() const {

        return storage_;

    }

    unsigned slot() const {

        assert(storage() != Unknown);

        return slot_;

    }

  private:

    Storage storage_;

    unsigned slot_;

};

class TypeSymbol : public Symbol

{

  public:

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

      : Symbol(scope, name, SourcePosition()),

        effective_(effective)

    {

        type_ = type;

    }

    Kind kind() const {

        return kType;

    }

    Handle<Type> effective() {

        return effective_;

    }

  private:

    ScopedRoot<Type> effective_;

};

class FunctionSymbol : public Symbol

{

  public:

    FunctionSymbol(Scope *scope, Handle<String> name, const SourcePosition &pos, Handle<FunctionType> type)

      : Symbol(scope, name, pos)

    {

        type_ = type;

    }

    Kind kind() const {

        return kFunction;

    }

    FunctionType *type() const {

        return FunctionType::cast(type_);

    }

};

class ConstantSymbol : public Symbol

{

  public:

    ConstantSymbol(Scope *scope, Handle<String> name, const SourcePosition &pos, Handle<Type> type,

                   const BoxedPrimitive &prim)

      : Symbol(scope, name, pos),

        value_(prim)

    {

        type_ = type;

    }

    Kind kind() const {

        return kConstant;

    }

    const BoxedPrimitive &value() const {

        return value_;

    }

  private:

    BoxedPrimitive value_;

};

class ImportSymbol : public Symbol

{

  public:

    ImportSymbol(Scope *scope, Handle<String> name, const SourcePosition &pos, Handle<Type> type,

                 unsigned index)

      : Symbol(scope, name, pos),

        index_(index)

    {

        type_ = type;

    }

    Kind kind() const {

        return kImport;

    }

    unsigned index() const {

        return index_;

    }

  private:

      unsigned index_;

};

class ImplicitSymbol : public Symbol

{

  public:

    ImplicitSymbol(Scope *scope, Handle<String> name, const SourcePosition &pos, Handle<Type> type,

                 unsigned index)

      : Symbol(scope, name, pos),

        index_(index),

        fieldIndex_(unsigned(-1))

    {

        type_ = type;

    }

    bool bound() const {

        return fieldIndex_ != unsigned(-1);

    }

    Kind kind() const {

        return kImplicit;

    }

    unsigned index() const {

        return index_;

    }

    void bind(unsigned fieldIndex) {

        fieldIndex_ = fieldIndex;

    }

    unsigned fieldIndex() const {

        assert(bound());

        return fieldIndex_;

    }

  private:

    unsigned index_;

    unsigned fieldIndex_;

};

}

#endif // _include_sp2_symbol_h_