---

class.h

Go to the documentation of this file.

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

#ifndef class_h
#define class_h

#include <vector>
#include "type_rep.h"
#include "symbol_table.h"
#include "symbol_name.h"
#include "scope.h"

//
// INTERFACE definition follows 
//


class Variable_symbol;
class Function_symbol;
class Class_symbol;

class Class_scope : public Abstract_scope {
    Class_symbol* sym;
    std::string   prefix;
 public:

public:  
  /****************************** Class_scope ******************************/
  Class_scope(Class_symbol* sym);
  
  ~Class_scope();
  
  Class_symbol* get_class_symbol() const;
  
  Type get_this_type() const;
  
  std::string get_unique_name(std::string name);
  
  Symbol_pair lookup_here(std::string name, bool for_decl);
  
  void add_symbol(std::string name, Symbol* sym);
  
  Variable_symbol* add_variable(Storage_class_specifier storage, Type type, Ptree* name, Ptree* init, Ptree* bitsize);
  
  Function_signature* add_function_decl(Storage_class_specifier storage, Function_specifier_set fspec, Type type, const Symbol_name& sym_name);
  
  void add_function_implementation(Function_signature* fsig, Block_scope* scope, Ptree* tree, Ptree* initializer);
  
  bool is_constructor(Ptree* tree);
};

class Class_symbol : public Type_symbol {
 public:
    typedef std::vector<Class_symbol*> bases_t;
    typedef std::vector<Variable_symbol*> members_t;
    typedef std::vector<Function_symbol*> memfuns_t;
 private:
    Kind             k;
    Abstract_scope*  in_scope;
    std::string      real_name;

    /* Base classes in left-to-right order */
    bases_t base_classes, virtual_base_classes;
    members_t members;
    memfuns_t member_functions;

    bool pod, aggregate;

    friend class Class_lookup_helper;
    friend class Class_scope;

    enum Assignment_operator {
        no_assignment_operator,
        const_assignment_operator,
        nonconst_assignment_operator
    };

public:  
  /****************************** Class_symbol *****************************/
  Class_symbol(Kind k, Abstract_scope* in_scope, std::string real_name);
  
  ~Class_symbol();
  
  Symbol::Kind get_kind() const;
  
  bool is_pod() const;
  
  bool is_aggregate() const;
  
  const std::string& get_real_name() const;
  
  bool is_base_class_of(Class_symbol* other) const;
  
  bool is_unique_base_class_of(Class_symbol* other) const;
  
  void enumerate_base_classes(bool with_virtuals, bases_t* output);
  
  void add_base_class(Class_symbol* sym, bool is_virt);
  
  void dump(std::ostream& os);
  
  Symbol_pair lookup_helper(std::string name) const;
  
  Class_scope* get_scope();
  
  Class_symbol::members_t::const_iterator mem_begin() const;
  
  Class_symbol::members_t::const_iterator mem_end() const;
  
  Class_symbol::bases_t::const_iterator vbc_begin() const;
  
  Class_symbol::bases_t::const_iterator vbc_end() const;
  
  Class_symbol::bases_t::const_iterator base_begin() const;
  
  Class_symbol::bases_t::const_iterator base_end() const;
  
  void start_definition(std::string basename);
  
  void finish_definition();

private:  
  void maybe_add_vbc(Class_symbol* sym);
  
  Function_signature* get_copy_ctor(Function_symbol* fsym, bool must_be_ref) const;
  
  bool implicit_copy_ctor_is_const() const;
  
  Class_symbol::Assignment_operator implicit_assignment_operator_style() const;
};

class Class_lookup_helper {
 protected:
    typedef std::vector<Class_symbol*> classes_t;
    classes_t result_set;
    classes_t hidden_vbcs;
    virtual bool predicate(Class_symbol* sym) = 0;

public:  
  virtual ~Class_lookup_helper();
  
  void add_class(Class_symbol* sym);
  
  void finish(Class_symbol* sym);

protected:  
  /************************** Class_lookup_helper **************************/
  
  Class_lookup_helper();
};

class Class_adder {
 public:
    virtual Class_symbol* add_class(Abstract_scope* scope, std::string name, Symbol::Kind k) = 0;
    virtual ~Class_adder() { }
};

class Default_class_adder : public Class_adder {

private:  
  Class_symbol* add_class(Abstract_scope* scope, std::string name, Symbol::Kind k);
};

/* content is:
   [kind name]
   [kind name bases content]
   [kind [nil nil] content] (!) */
Class_symbol* parse_class(Ptree* tree, Abstract_scope* scope, Ptree* name_for_anon, bool is_type_declaration, Class_adder& adder);

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



inline Class_symbol*
Class_scope::get_class_symbol() const
{
    return sym;
}


inline bool
Class_symbol::is_pod() const
{
    return pod;
}


inline bool
Class_symbol::is_aggregate() const
{
    return aggregate;
}


inline const std::string&
Class_symbol::get_real_name() const
{
    return real_name;
}


inline Symbol_pair
Class_symbol::lookup_helper(std::string name) const
{
    // return Symbol_table::get_instance().get_symbol(get_name() + "::" + name);
    return Symbol_table::get_instance().
        get_symbol(Symbol_name::get_mangled_symbol_name(Symbol_name::get_mangled_scope_from_symbol(get_name()), name));
}


inline Class_symbol::members_t::const_iterator
Class_symbol::mem_begin() const
{
    return members.begin();
}


inline Class_symbol::members_t::const_iterator
Class_symbol::mem_end() const
{
    return members.end();
}


inline Class_symbol::bases_t::const_iterator
Class_symbol::vbc_begin() const
{
    return virtual_base_classes.begin();
}


inline Class_symbol::bases_t::const_iterator
Class_symbol::vbc_end() const
{
    return virtual_base_classes.end();
}


inline Class_symbol::bases_t::const_iterator
Class_symbol::base_begin() const
{
    return base_classes.begin();
}


inline Class_symbol::bases_t::const_iterator
Class_symbol::base_end() const
{
    return base_classes.end();
}

#endif // class_h

---