---

symbol_name.h

Go to the documentation of this file.

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

#ifndef symbol_name_h
#define symbol_name_h

#include <string>
#include "type_rep.h"
#include "symbol_table.h"

//
// INTERFACE definition follows 
//


class Ptree;
class Abstract_scope;
class Symbol_name {
 public:
    enum Kind {
        k_Normal,               
        k_Operator,             
        k_Alloc,                
        k_Constructor,          
        k_Destructor,           
        k_Conversion            
    };

    static const char CONVERSION_OPERATOR_NAME[], CONSTRUCTOR_NAME[], DESTRUCTOR_NAME[],
        PTR_OPERATOR_NAME[], CALL_OPERATOR_NAME[], ASSIGNMENT_OPERATOR_NAME[],
        INDEX_OPERATOR_NAME[], NEW_OPERATOR_NAME[], ANEW_OPERATOR_NAME[],
        DELETE_OPERATOR_NAME[], ADELETE_OPERATOR_NAME[], COMMA_OPERATOR_NAME[];
 private:
    std::string     basename;   
    Abstract_scope* scope;      
    bool            qualified;  
    Type            conv_type;  
    Kind            kind;       
    Ptree*          tpl_args;   
    Abstract_scope* start_scope; 

public:  
  Symbol_name(std::string s, Abstract_scope* scope, Kind k);
  
  Symbol_name(Ptree* tree, Abstract_scope* const scope, bool is_fdecl);
  
  ~Symbol_name();
  
  static bool is_qualified_name(Ptree* p);
  
  static Abstract_scope* lookup_symbol_in_scope(Ptree* p, Abstract_scope* scope, Abstract_scope* start_scope);
  
  bool is_qualified() const;
  
  std::string get_name() const;
  
  Symbol_name::Kind get_kind() const;
  
  Abstract_scope* get_scope() const;
  
  Type get_type() const;
  
  bool is_template() const;
  
  Ptree* get_template_args() const;
  
  Symbol_pair lookup_for_use(bool qual) const;
  
  Symbol_pair lookup_for_decl() const;
  
  /***************************** Name Mangling *****************************/
  
  static std::string gensym();
  
  static std::string get_unnamed_namespace_name();
  
  static std::string get_mangled_symbol_name(std::string scope, std::string name);
  
  static std::string get_mangled_scope_from_symbol(std::string name);
  
  static std::string get_mangled_function_name(std::string fname, Type t, Type this_type);
  
  static std::string get_mangled_template_name(std::string name, const Type_vector& types);
  
  static std::string get_mangled_block_scope(std::string fname);
  
  static std::string get_basename_from_symbol(std::string sym, std::string::size_type len);
  
  static std::string get_block_name();
  
  static const char* get_operator_name(Ptree* tree);

private:  
  void init_name(Abstract_scope* s, Ptree* p, bool is_fdecl);
};

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



inline std::string
Symbol_name::get_name() const
{
    return basename;
}


inline Symbol_name::Kind
Symbol_name::get_kind() const
{
    return kind;
}


inline bool
Symbol_name::is_template() const
{
    return tpl_args != 0;
}


inline Ptree*
Symbol_name::get_template_args() const
{
    return tpl_args;
}

#endif // symbol_name_h

---