---

symbol_table.h

Go to the documentation of this file.

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

#ifndef symbol_table_h
#define symbol_table_h

#include <map>
#include <string>
#include <vector>
#include <iosfwd>
#include "type_rep.h"

//
// INTERFACE definition follows 
//


class Abstract_scope;

class Symbol {
    std::string name;
    std::string::size_type base_len;
 public:
    const std::string& get_name() const { return name; }
    void set_name(const std::string& n, std::string::size_type bl) {
        name = n; base_len = bl;
    }

    enum Kind {
        // this list must match the array in Symbol::dump
        k_Variable,
        k_Namespace,
        k_Typedef,
        k_Function,

        k_Enum,
        k_ClassOrStruct,
        k_Union,
        k_ClassTemplate
    };

    enum Status {
        /* Symbol has been used indirectly, but not yet defined.
           For example, "extern int errno" in a function. 
           Must be first so that it converts to false. */
        st_Undefined,
        /* Symbol has been declared but not defined */
        st_Declared,
        /* Symbol has been defined */
        st_Defined
    };

    static bool is_tagged(Kind k) { return k >= k_Enum; }
    bool is_tagged() const { return is_tagged(get_kind()); }

    Status get_status() const { return status; }
    bool   is_defined() const { return status == st_Defined; }
    bool   is_declared() const { return status >= st_Declared; }

    virtual Kind get_kind() const = 0;
 private:
    Status status;

public:  
  /********************************* Symbol ********************************/
  Symbol();
  
  virtual ~Symbol();
  
  virtual Abstract_scope* get_scope();
  
  void set_status(Status st);
  
  std::string get_basename() const;
  
  virtual void dump(std::ostream& out);
};

struct Symbol_pair {
    Symbol* untag;
    Symbol* tag;
    Symbol_pair(Symbol* u, Symbol* t) : untag(u), tag(t) { }
    Symbol_pair() : untag(0), tag(0) { }
    operator bool() const { return untag != 0; }
};

class Symbol_table {
    static Symbol_table instance;
    typedef std::map<std::string, Symbol_pair> content_type;
    content_type content;
 public:
    typedef content_type::const_iterator Sym_it;

    static Symbol_table& get_instance() { return instance; }
    static const char* dump_flags;
    Sym_it begin() const { return content.begin(); }
    Sym_it end() const { return content.end(); }

public:  
  Symbol_table();
  
  virtual ~Symbol_table();
  
  void add_symbol(std::string name, std::string::size_type base_len, Symbol* sym);
  
  void set_peer(Symbol* orig, Symbol* faelschung);
  
  Symbol_pair get_symbol(std::string name) const;
  
  void dump(std::ostream& out);
  
  static bool has_dump_flag(char c);
  
  void clear();
};

class Type_symbol : public Symbol {
 public:
    void set_defined() { set_status(st_Defined); }

public:  
  /**************************** Type_symbol ****************************/
  Type_symbol();
  
  ~Type_symbol();
  
  Type get_type() const;
};

//
// IMPLEMENTATION of inline functions (and needed classes)
//



/********************************* Symbol ********************************/

inline Symbol::Symbol()
    : name(), base_len(0), status(st_Undefined) 
{
    // std::cout << "make " << (void*)this << "\n";
}

#endif // symbol_table_h

---