/**
 *  \file variable.cpp
 *  \brief Variable-related stuff
 *  \author Stefan Reuther
 */

INTERFACE:

#include "symbol_table.h"
#include "type_rep.h"

class Class_symbol;

class Variable_symbol : public Symbol {
    Type                     type;
    Storage_class_specifier  storage_class;
    Ptree*                   initializer;
    Ptree*                   bitsize;
    bool                     has_addr; // false for enum constants
    Class_symbol*            in_class;
 public:
    Type                     get_type()          const { return type; }
    Storage_class_specifier  get_storage_class() const { return storage_class; }
    bool                     has_address()       const { return has_addr; }
    Ptree*                   get_initializer()   const { return initializer; }
    Ptree*                   get_bitsize()       const { return bitsize; }
    bool                     is_member_variable() const { return storage_class == s_Member || storage_class == s_Mutable; }
};

IMPLEMENTATION:

#include "annotation.h"

/** This ctor is used for variables. */
PUBLIC 
Variable_symbol::Variable_symbol(Type type, Storage_class_specifier storage,
                                 Ptree* initializer, Ptree* bitsize, 
                                 Symbol::Status status)
    : Symbol(), type(type), storage_class(storage),
      initializer(initializer), bitsize(bitsize), has_addr(true),
      in_class(0)
{
    set_status(status);
}

/** This ctor is used for enum values. */
PUBLIC 
Variable_symbol::Variable_symbol(Type type, Storage_class_specifier storage,
                                 Ptree* initializer, Ptree* bitsize, 
                                 bool has_address)
    : Symbol(), type(type), storage_class(storage),
      initializer(initializer), bitsize(bitsize), has_addr(has_address),
      in_class(0)
{
    set_status(st_Defined);
}

PUBLIC Symbol::Kind
Variable_symbol::get_kind() const
{
    return k_Variable;
}

PUBLIC void
Variable_symbol::set_class(Class_symbol* csym)
{
    assert(is_member_variable());
    in_class = csym;
}

PUBLIC inline Class_symbol*
Variable_symbol::get_class() const
{
    return in_class;
}

PUBLIC void
Variable_symbol::define_variable(Storage_class_specifier storage,
                                 Ptree* initializer, Ptree* bitsize,
                                 Status status)
{
    set_status(status);
    this->storage_class = storage;
    this->initializer   = initializer;
    this->bitsize       = bitsize;
}

PUBLIC void
Variable_symbol::dump(std::ostream& os)
{
    Symbol::dump(os);
    os << ", type is `" << type.get_human_readable_type() << "'";
    if (initializer)
        os << ", has initializer";
    if (bitsize)
        os << ", has bitsize";
    if (!has_address())
        os << ", has no address";
    os << ", storage " << get_storage_specifier_name(storage_class);
    if (initializer && Symbol_table::has_dump_flag('i')) {
        os << "\n  Initializer is:\n";
        print_annotated_tree(os, "  |  ", initializer, Symbol_table::has_dump_flag('c'));
    }
}