---

type_rep.h

Go to the documentation of this file.

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

#ifndef type_rep_h
#define type_rep_h

#include <string>
#include <vector>

//
// INTERFACE definition follows 
//


class Ptree;
class Abstract_scope;
class Type_symbol;
/*
  Possible types:
    fundamental types ([us\epsilon][ihljcfdebwv])
    const T -> "C<T>"
    volatile T -> "V<T>"
    restrict T (why not) -> "N<T>"
    pointer-to-T -> "P<T>"
    reference-to-T -> "R<T>"
    function(T1,T2,T3)-returning-TR -> "F<T1><T2><T3>_<TR>"
    array[dimension]-of-T -> "A<n><T>"
    pointer-to-member-of-T-which-has-type-TM -> "M<TM><T>"
    pointer-to-member-function(T1,T2,T3)-returning-TR-of-T -> "MF<T1><T2><T3>_<TR><T>
    class/struct/union "Q<len><name>"
    template arg "T<nn>"
    enum "Q<len><name>"
    ... -> "E"
  Names: as in C++: foo::bar::x
 */

enum Storage_class_specifier {
    s_None,
    s_Auto,
    s_Parameter,
    s_Register,
    s_Static,
    s_Extern,
    s_Mutable,                  // implies member
    s_Member                    // this one can't be specified in source
};

enum Function_specifier {
    f_None     = 0,
    f_Inline   = 1,
    f_Virtual  = 2,
    f_Explicit = 4,
    f_Abstract = 8
};
typedef int Function_specifier_set;

class Type {
    std::string code;
    int qualifiers;
    friend class Function_type_maker;
 public:
    enum Qualifier {
        q_Const,                
        q_Volatile,             
        q_Restrict              
    };
    enum Kind {
        k_Fundamental,
        k_Pointer   = 'P',
        k_Reference = 'R',
        k_Function  = 'F',
        k_Array     = 'A',
        k_Member    = 'M',      // member pointer or member function pointer
        k_Userdef   = 'Q',
        k_Ellipsis  = 'E',
        k_Template  = 'T',
        k_Nothing   = 'O'       // no type, i.e. ctor or operator
    };
    static const int ignore_qual = 0;

    bool is_qualified(Qualifier q) const { return qualifiers & (1 << q); }
    bool is_qualified() const            { return qualifiers != 0; }
    void add_qualifier(Qualifier q)      { qualifiers |= (1 << q); }
    void remove_qualifier(Qualifier q)   { qualifiers &= ~(1 << q); }
    bool is_valid() const { return code.length() != 0; }

    void copy_qualifiers(const Type& other) { qualifiers |= other.qualifiers; }

    const std::string& get_encoded_type() const { return code; }

    Type get_unqualified_type() const { return Type(code); }

    bool operator==(const Type& rhs) const { return rhs.code == code && ((rhs.qualifiers ^ qualifiers) & ~ignore_qual) == 0; }
    bool operator!=(const Type& rhs) const { return rhs.code != code || ((rhs.qualifiers ^ qualifiers) & ~ignore_qual) != 0; }

    bool is_more_qualified_than(const Type& other) const { return (qualifiers & ~other.qualifiers) != 0; }
    bool is_same_qualified_as(const Type& other) const { return ((qualifiers ^ other.qualifiers) & ~ignore_qual) == 0; }
    bool is_same_unqualified_type(const Type& other) const { return code == other.code; }

public:  
  /* 3.9.2 [basic.compound]
     - array of TYPE
     - function
     - pointers [dcl.ptr]
     - references [dcl.ref]
     - class [class]
     - union [class.union]
     - enum [dcl.enum]
     - member pointer [dcl.mptr] */
  
  Type();
  
  Type(std::string encoded);
  
  static Type get_named_type(std::string name);
  
  Type::Kind get_kind() const;
  
  Type make_pointer_type() const;
  
  Type make_reference_type() const;
  
  Type make_array_type(Ptree* dimension) const;
  
  Type make_member_type(Type membertype) const;
  
  Type get_basis_type() const;
  
  Type sans_reference() const;
  
  Type sans_array() const;
  
  Type get_class_type() const;
  
  Type get_member_type() const;
  
  Type get_return_type() const;
  
  std::string get_function_signature() const;
  
  Type get_function_arg(int n) const;
  
  int get_num_function_args() const;
  
  int get_template_argindex() const;
  
  std::string get_human_readable_type() const;
  
  /******************************* Accessors *******************************/
  
  bool is_void() const;
  
  bool is_float() const;
  
  bool is_int() const;
  
  bool is_complete() const;
  
  bool is_object_type() const;
  
  bool is_arithmetic_type() const;
  
  bool is_scalar_type() const;
  
  bool is_pod() const;
  
  bool is_aggregate() const;
  
  bool is_compound_type() const;
  
  bool is_enum_type() const;
  
  bool is_class_type() const;
  
  Type_symbol* get_type_symbol() const;
  
  Type with_qualifier(Type::Qualifier q) const;
  
  Type with_first_arg(Type t) const;
  
  Type with_qualifiers(const Type& other) const;
  
  Type get_promoted_integer() const;
  
  bool is_qualification_convertible_to(Type t) const;

private:  
  Type(std::string code, int qualifiers);
  
  std::string encode_qualifiers(std::string prefix) const;
  
  static std::string eat_type(std::string s);
};

class Function_type_maker {
    std::string types;

public:  
  /*************************** Function_type_maker ***************************/
  
  Function_type_maker();
  
  void add_parameter(Type t);
  
  void add_ellipsis();
  
  Type make_function_type(Type return_type) const;
};

/* built-in types */
extern Type int_type, uint_type, short_type, ushort_type, long_type,
    ulong_type, llong_type, ullong_type, char_type, schar_type,
    uchar_type, float_type, double_type, ldouble_type, bool_type,
    wchar_type, void_type, ctor_type;

/* aliases there-to */
extern Type ptrdiff_type, size_type;

typedef std::vector<Type> Type_vector;

bool parse_qualifier(Ptree* tree, Type& type);

Type parse_type(Ptree* tree, Abstract_scope* scope, Ptree* name_for_anon, bool is_type_declaration);

/****************** Function / Storage Class Specifiers ******************/

bool parse_specifier(Ptree* tree, Storage_class_specifier* scs, Function_specifier_set* fs);

void parse_specifiers(Ptree* tree, Storage_class_specifier* scs, Function_specifier_set* fs);

const char* get_storage_specifier_name(Storage_class_specifier x);

std::string get_function_specifier_name(Function_specifier_set s);

Type make_unary_function_type(Type arg, Type ret);

Type make_binary_function_type(Type arg, Type brg, Type ret);

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



inline Type
Type::make_pointer_type() const
{
    return Type(encode_qualifiers("P"));
}


inline Type
Type::make_reference_type() const
{
    return Type(encode_qualifiers("R"));
}


/******************************* Accessors *******************************/

inline bool
Type::is_void() const
{
    return code.length() && code[0] == 'v';
}


inline bool
Type::is_float() const
{
    return code.length() && (code[0] == 'd' || code[0] == 'e' || code[0] == 'f');
}


inline bool
Type::is_compound_type() const
{
    return get_kind() != k_Fundamental;
}


inline Type
Type::with_qualifier(Type::Qualifier q) const
{
    return Type(code, qualifiers | (1 << q));
}


inline Type
Type::with_first_arg(Type t) const
{
    assert(get_kind() == k_Function);
    Type t2 = *this;
    t2.code.insert(1, t.encode_qualifiers(""));
    return t2;
}


inline Type
Type::with_qualifiers(const Type& other) const
{
    return Type(code, qualifiers | other.qualifiers);
}

#endif // type_rep_h

---