---

symbol_name.cc

Go to the documentation of this file.

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

#include "symbol_name.h"
#include "symbol_name_i.h"


#line 55 "symbol_name.cpp"

Symbol_name::Symbol_name(std::string s, Abstract_scope* scope, Kind k)
    : basename(s), scope(scope), qualified(0), conv_type(), kind(k), tpl_args(0), start_scope(scope)
{ }

#line 76 "symbol_name.cpp"

Symbol_name::Symbol_name(Ptree* tree, Abstract_scope* const scope, bool is_fdecl)
    : scope(0), qualified(false), tpl_args(0), start_scope(scope)
{
    if (!tree) {
        /* anonymous object */
        basename = gensym();
        kind     = k_Normal;
        this->scope = scope;
    } else if (!is_qualified_name(tree)) {
        /* it's a leaf. Leaf it so. */
        init_name(scope, tree, is_fdecl);
    } else {
        /* qualified name */
        qualified = true;

        Ptree* p         = tree;
        bool look_global = true;
        Abstract_scope* current_scope = scope;
#define ADVANCE(p) (p = p->Cdr(), assert(p != 0))
        if (p->Car()->Eq("::")) {
            /* rooted lookup */
            look_global = false;
            current_scope = current_scope->get_global_scope();
            ADVANCE(p);
        }

        while (p && p->Cdr()) {
            Ptree* ele = p->Car();   // a scope name
            if (look_global) {
                Abstract_scope* s;
                while (current_scope && !(s = lookup_symbol_in_scope(ele, current_scope, start_scope)))
                    current_scope = current_scope->get_parent();
                if (!current_scope)
                    compile_error("no such scope " + std::string(ele->ToString()));
                current_scope = s;
            } else {
                current_scope = lookup_symbol_in_scope(ele, current_scope, start_scope);
                if (!current_scope)
                    compile_error("no such scope " + std::string(ele->ToString()));
            }
            look_global = false;
            ADVANCE(p);
            expect_ptree(p->Car(), "::");
            ADVANCE(p);
        }

        /* now we have reached the final leaf */
        init_name(current_scope, p->Car(), is_fdecl);
    }
    assert(this->scope);
}

#line 134 "symbol_name.cpp"


Symbol_name::~Symbol_name()
{ }

#line 138 "symbol_name.cpp"

bool
Symbol_name::is_qualified_name(Ptree* p)
{
    return (!p->IsLeaf() && p->Length() >= 2
            && (p->First()->Eq("::") || p->Second()->Eq("::")));
}

#line 148 "symbol_name.cpp"

Abstract_scope*
Symbol_name::lookup_symbol_in_scope(Ptree* p, Abstract_scope* scope, Abstract_scope* start_scope)
{
    Symbol_pair sp;
    if (p->IsLeaf()) {
        /* class or namespace */
        sp = scope->lookup_here(p->ToString(), false);
        Abstract_scope* s;
        if (sp.tag && (s = sp.tag->get_scope()))
            return s;
        if (sp.untag && (s = sp.untag->get_scope()))
            return s;
    } else {
        /* template */
        assert(p->Length() == 2);
        sp = scope->lookup_here(p->Car()->ToString(), false);
        Template_class_symbol* tcs = dynamic_cast<Template_class_symbol*>(sp.tag);
        if (tcs)
            return tcs->get_specialisation_from_ptree(p->Second(), start_scope)->get_scope();
    }

    if (sp.untag && sp.untag->get_kind() != Symbol::k_Function && sp.untag->get_kind() != Symbol::k_Variable)
        compile_error("not a scope name: " + std::string(p->ToString()));
    return 0;
}

#line 180 "symbol_name.cpp"

void
Symbol_name::init_name(Abstract_scope* s, Ptree* p, bool is_fdecl)
{
    if (!p->IsLeaf()) {
        if (p->Car()->Eq('~')) {
            if (!s->is_constructor(p->Second()))
                compile_error("invalid destructor name");
            basename = DESTRUCTOR_NAME;
            kind     = k_Destructor;
            scope    = s;
            return;
        }
        if (p->Car()->Eq("operator")) {
            /* operator */
            assert(p->Length() == 2);
            if (const char* pn = get_operator_name(p->Second())) {
                /* it's a normal operator */
                basename = pn;
                if (pn == NEW_OPERATOR_NAME || pn == ANEW_OPERATOR_NAME || pn == DELETE_OPERATOR_NAME || pn == ADELETE_OPERATOR_NAME)
                    kind = k_Alloc;
                else
                    kind = k_Operator;
                scope = s;
                return;
            }
            
            /* conversion operator */
            
            /*  This sucks.
                
                parse.cc, rOperatorName:
                  X                                normal operator
                  Reserved(new), Reserved(delete)  operator new
                  [Reserved(new) \[ \]]            array new/delete
                  [( )]                            funcall op
                  [\[ \]]                          index op
                  =>       leaf of type RESERVED
                  -or-  list starting with RESERVED leaf or "(" or "["
                  -or-  leaf containing operator (i.e. non-alphabetic)
                  
                  
                  typename
                  [typename [ptr-operators...]]
                  ...where typname = type-specifier-list or name
                  i.e.
                  [operator [a [*]]
                  [operator [:: a]]
                  [operator [a [* *]]]
                  [operator [[int] [[a :: *]]]]
                  [operator a]
                  [operator [a :: b]]
                  [operator [[a :: b] [*]]]
                  [operator [const [bool]]]
                  [operator [[bool] const]]
                  [operator [const a]]
                  
                  => single type if
                    leaf
                  => type + ptr-ops
                          list of length 2
                    -and- first is not a "::" */
            Ptree* opn = p->Second();
            if (!opn->IsLeaf() && opn->Length() == 2 && !opn->Car()->Eq("::") && !opn->Second()->IsLeaf()) {
                /* this test doesn't wield out "const bool" etc. Use
                   brute force. Bummer, maybe parse_type does assert
                   or printBacktrace when something fails. Did I
                   already say this sucks? */
                try {
                    Type t = parse_type(opn->First(), start_scope, 0, false);
                    if (!parse_abstract_declarator(opn->Second(), start_scope, &t))
                        compile_error("invalid abstract-declarator for conversion operator");
                    conv_type = t;
                    kind = k_Conversion;
                    basename = CONVERSION_OPERATOR_NAME;
                    scope = s;
                    return;
                }
                catch(...) { }
            }
            /* we're here when it's just one type */
            conv_type = parse_type(opn, start_scope, 0, false);
            kind = k_Conversion;
            basename = CONVERSION_OPERATOR_NAME;
            scope = s;
            return;
        }

        /* must be template */
        if (p->Length() != 2)
            bogus_ptree_error("expected [name [< tplargs >]]", p);
        tpl_args = p->Second();
        p = p->First();
    }

    if (!p->IsLeaf())
        bogus_ptree_error("expected leaf", p);
    
    if (is_fdecl && s->is_constructor(p)) {
        basename = CONSTRUCTOR_NAME;
        kind     = k_Constructor;
        scope    = s;
    } else {
        basename = p->ToString();
        kind     = k_Normal;
        scope    = s;
    }
}

#line 295 "symbol_name.cpp"

bool
Symbol_name::is_qualified() const
{
    return qualified;
}

#line 317 "symbol_name.cpp"

Abstract_scope*
Symbol_name::get_scope() const
{
    return scope;
}

#line 325 "symbol_name.cpp"

Type
Symbol_name::get_type() const
{
    assert(get_kind() == k_Conversion);
    return conv_type;
}

#line 347 "symbol_name.cpp"

Symbol_pair
Symbol_name::lookup_for_use(bool qual) const
{
    Symbol_pair sp;
    if (qual || is_qualified())
        sp = get_scope()->lookup_here(get_name(), false);
    else
        sp = get_scope()->lookup_unqualified(get_name());

    if (is_template()) {
        Template_class_symbol* tcs = dynamic_cast<Template_class_symbol*>(sp.tag);
        if (!tcs)
            compile_error(get_name() + " is not a template");
        
        Type_vector tv;
        parse_template_arg_list(tpl_args, start_scope, &tv);
        sp.tag = sp.untag = tcs->get_specialisation(tv);
    }
    return sp;
}

#line 373 "symbol_name.cpp"

Symbol_pair
Symbol_name::lookup_for_decl() const
{
    return get_scope()->lookup_here(get_name(), true);
}

#line 380 "symbol_name.cpp"

/***************************** Name Mangling *****************************/

std::string
Symbol_name::gensym()
{
    static int counter = 0;
    ++counter;
    std::ostringstream s;
    s << "__" << counter;
    return s.str();
}

#line 393 "symbol_name.cpp"

std::string
Symbol_name::get_unnamed_namespace_name() 
{
    // FIXME: g++ derives this name from the input file name, time,
    // and whatever. So should we do, too.
    return "__unnamed";
}

#line 402 "symbol_name.cpp"

std::string
Symbol_name::get_mangled_symbol_name(std::string scope, std::string name)
{
#ifdef OLD_MANGLER
    if (scope.length())
        return scope + "::" + name;
    else
        return name;
#else
    return name + scope;
#endif
}

#line 417 "symbol_name.cpp"

std::string
Symbol_name::get_mangled_scope_from_symbol(std::string name)
{
#ifdef OLD_MANGLER
    return name;
#else
    std::ostringstream os;
    os << "?Q" << name.length() << name;
    return os.str();
#endif
}

#line 431 "symbol_name.cpp"

std::string
Symbol_name::get_mangled_function_name(std::string fname, Type t, Type this_type)
{
#ifdef OLD_MANGLER
    return fname + "__" + t.make_pointer_type().get_encoded_type().substr(1);
#else
    std::string type = t.get_function_signature();
    if (this_type.is_valid()) {
        if (this_type.is_qualified(Type::q_Volatile))
            type.insert(0, "V");
        if (this_type.is_qualified(Type::q_Const))
            type.insert(0, "C");
    }
    std::ostringstream os;
    os << fname << "?F" << type.length() << type;
    return os.str();
#endif
}

#line 452 "symbol_name.cpp"

std::string
Symbol_name::get_mangled_template_name(std::string name, const Type_vector& types)
{
#ifdef OLD_MANGLER
    name += "__";
    for (unsigned i = 0; i < types.size(); ++i)
        name += types[i].make_pointer_type().get_encoded_type().substr(1);
    return name;
#else
    std::string type_sig;
    for (unsigned i = 0; i < types.size(); ++i)
        type_sig += types[i].make_pointer_type().get_encoded_type().substr(1);
    std::ostringstream os;
    os << name << "?T" << type_sig.length() << type_sig;
    return os.str();
#endif
}

#line 472 "symbol_name.cpp"

std::string
Symbol_name::get_mangled_block_scope(std::string fname)
{
    return fname + get_block_name();
}

#line 480 "symbol_name.cpp"

std::string
Symbol_name::get_basename_from_symbol(std::string sym, std::string::size_type len)
{
#ifdef OLD_MANGLER
    return sym.substr(sym.length()-len, len);
#else
    return sym.substr(0, len);
#endif
}

#line 490 "symbol_name.cpp"

std::string
Symbol_name::get_block_name()
{
    static int counter = 0;
    ++counter;
    std::ostringstream s;
#ifdef OLD_MANGLER
    s << "." << counter;
#else
    s << "?" << counter;
#endif
    return s.str();
}
#line 505 "symbol_name.cpp"

const char Symbol_name::CONVERSION_OPERATOR_NAME[] = "__cvt",
    Symbol_name::CONSTRUCTOR_NAME[] = "__ctor",
    Symbol_name::DESTRUCTOR_NAME[] = "__dtor",
    Symbol_name::PTR_OPERATOR_NAME[] = "__opar",
    Symbol_name::CALL_OPERATOR_NAME[] = "__opf",
    Symbol_name::ASSIGNMENT_OPERATOR_NAME[] = "__opas",
    Symbol_name::INDEX_OPERATOR_NAME[] = "__opi",
    Symbol_name::NEW_OPERATOR_NAME[] = "__opnew",
    Symbol_name::ANEW_OPERATOR_NAME[] = "__opanew",
    Symbol_name::DELETE_OPERATOR_NAME[] = "__opdel",
    Symbol_name::ADELETE_OPERATOR_NAME[] = "__opadel",
    Symbol_name::COMMA_OPERATOR_NAME[] = "__opcom";

#line 518 "symbol_name.cpp"

const char*
Symbol_name::get_operator_name(Ptree* tree)
{
    if (tree->IsLeaf()) {
        if (tree->Eq('+'))
            return "__opp";     // plus
        else if (tree->Eq('-'))
            return "__opm";     // minus
        else if (tree->Eq('*'))
            return "__opt";     // times
        else if (tree->Eq('/'))
            return "__opd";     // divide
        else if (tree->Eq('&'))
            return "__opa";     // and
        else if (tree->Eq('!'))
            return "__opn";     // not
        else if (tree->Eq('~'))
            return "__opc";     // complement
        else if (tree->Eq('%'))
            return "__opr";     // remainder
        else if (tree->Eq(','))
            return COMMA_OPERATOR_NAME;   // comma
        else if (tree->Eq('^'))
            return "__opx";     // xor
        else if (tree->Eq('|'))
            return "__opo";     // or
        else if (tree->Eq('<'))
            return "__oplt";    // less than
        else if (tree->Eq('>'))
            return "__opgt";    // greater than
        else if (tree->Eq('='))
            return ASSIGNMENT_OPERATOR_NAME;    // assign
        else if (tree->Eq("++"))
            return "__oppp";    // plusplus
        else if (tree->Eq("--"))
            return "__opmm";    // minusminus
        else if (tree->Eq("<<"))
            return "__opll";    // left left / less less
        else if (tree->Eq(">>"))
            return "__oprr";    // right right
        else if (tree->Eq("<="))
            return "__ople";
        else if (tree->Eq(">="))
            return "__opge";
        else if (tree->Eq("=="))
            return "__opeq";
        else if (tree->Eq("!="))
            return "__opne";
        else if (tree->Eq("->"))
            return PTR_OPERATOR_NAME;    // arrow
        else if (tree->Eq("&&"))
            return "__opaa";    // andand
        else if (tree->Eq("||"))
            return "__opoo";    // oror
        else if (tree->Eq("*="))
            return "__optas";    // times-assign
        else if (tree->Eq("/="))
            return "__opdas";
        else if (tree->Eq("%="))
            return "__opras";
        else if (tree->Eq("+="))
            return "__oppas";
        else if (tree->Eq("-="))
            return "__opmas";
        else if (tree->Eq(">>="))
            return "__oprras";
        else if (tree->Eq("<<="))
            return "__opllas";
        else if (tree->Eq("&="))
            return "__opaas";
        else if (tree->Eq("^="))
            return "__opxas";
        else if (tree->Eq("|="))
            return "__opoas";
        else if (tree->Eq(".*"))
            return "__oppm";
        else if (tree->Eq("->*"))
            return "__opppm";
        else if (tree->Eq("new"))
            return NEW_OPERATOR_NAME;
        else if (tree->Eq("delete"))
            return DELETE_OPERATOR_NAME;
        else
            return 0;
    } else {
        Ptree* c = tree->Car();
        if (c->Eq('['))
            return INDEX_OPERATOR_NAME; // index
        else if (c->Eq('('))
            return CALL_OPERATOR_NAME;  // funcall
        else if (c->Eq("new"))
            return ANEW_OPERATOR_NAME;
        else if (c->Eq("delete"))
            return ADELETE_OPERATOR_NAME;
        else
            return 0;
    }
}

---