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