---

symbol_table.cc

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#include "symbol_table.h"
#include "symbol_table_i.h"

#line 101 "symbol_table.cpp"

/****************************** Symbol_table *****************************/

Symbol_table Symbol_table::instance;
#line 105 "symbol_table.cpp"

const char* Symbol_table::dump_flags = "";

#line 107 "symbol_table.cpp"

Symbol_table::Symbol_table()
{ }

#line 114 "symbol_table.cpp"


Symbol_table::~Symbol_table()
{ }

#line 118 "symbol_table.cpp"

void
Symbol_table::add_symbol(std::string name, std::string::size_type base_len, Symbol* sym)
{
    content_type::iterator i = content.find(name);
    if (i != content.end()) {
        /* symbol already there; for example, `int stat(...)' and
           `struct stat' */
        if (sym->is_tagged()) {
            if (!i->second.tag || i->second.tag == i->second.untag)
                /* function there, structure being added. I guess
                   the second part can't happen */
                i->second.tag = sym;
            else
                compile_error("redeclaration of `" + name + "' not allowed");
        } else {
            if (i->second.tag == i->second.untag)
                /* structure already there, function being added */
                i->second.untag = sym;
            else
                compile_error("redeclaration of `" + name + "' not allowed");
        }
    } else {
        /* symbol does not exist yet */
        if (sym->is_tagged())
            content[name] = Symbol_pair(sym, sym);
        else
            content[name] = Symbol_pair(sym, 0);
    }
    sym->set_name(name, base_len);
}

#line 150 "symbol_table.cpp"

void
Symbol_table::set_peer(Symbol* orig, Symbol* faelschung)
{
    assert(!orig->is_tagged());
    assert(faelschung->is_tagged());
    content[orig->get_name()].tag = faelschung;
}

#line 162 "symbol_table.cpp"

Symbol_pair
Symbol_table::get_symbol(std::string name) const
{
    content_type::const_iterator i = content.find(name);
    if (i != content.end())
        return i->second;
    else
        return Symbol_pair(0, 0);
}

#line 173 "symbol_table.cpp"

void
Symbol_table::dump(std::ostream& out)
{
    for (content_type::const_iterator i = content.begin(); i != content.end(); ++i) {
        out << i->first << ":\n";
        i->second.untag->dump(out);
        out << "\n";
        if (i->second.tag && i->second.tag != i->second.untag)
            i->second.tag->dump(out), out << "\n";
    }
}

#line 186 "symbol_table.cpp"

bool
Symbol_table::has_dump_flag(char c)
{
    const char* p = dump_flags;
    while (*p)
        if (*p++ == c)
            return true;
    return false;
}

#line 196 "symbol_table.cpp"

void
Symbol_table::clear()
{
    content_type().swap(content);
}

#line 211 "symbol_table.cpp"


Symbol::~Symbol()
{ 
    // std::cout << "destroy " << (void*)this << "\n";
}

#line 217 "symbol_table.cpp"

Abstract_scope*
Symbol::get_scope() 
{
    return 0;
}

#line 224 "symbol_table.cpp"

void
Symbol::set_status(Status st)
{
    assert(st >= status);       // we can only raise the status,
                                // there's no way to undefine
                                // something
    status = st;
}

#line 234 "symbol_table.cpp"

std::string
Symbol::get_basename() const
{
    // return name.substr(name.length() - base_len);
    return Symbol_name::get_basename_from_symbol(name, base_len);
}

#line 241 "symbol_table.cpp"

void
Symbol::dump(std::ostream& out)
{
    static const char*const names[] = {
        "variable",
        "namespace",
        "typedef",
        "function",
        "enum",
        "class",
        "union",
        "class template"
    };
    const char* st = is_defined() ? "" : is_declared() ? "undefined " : "undeclared ";

    out << "- " << st << names[get_kind()];
}

#line 261 "symbol_table.cpp"

/**************************** Type_symbol ****************************/


Type_symbol::Type_symbol()
    : Symbol()
{ }

#line 268 "symbol_table.cpp"


Type_symbol::~Type_symbol()
{ }

#line 272 "symbol_table.cpp"

Type
Type_symbol::get_type() const
{
    return Type::get_named_type(get_name());
}

---