---

annotation.cc

Go to the documentation of this file.

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

#include "annotation.h"
#include "annotation_i.h"


#line 339 "annotation.cpp"
static const char*
unmangle(const char* name);

#line 48 "annotation.cpp"


Annotation::Annotation(Type type, Symbol* sym)
    : type(type), symbol(sym)
{ }

#line 53 "annotation.cpp"


Annotation::~Annotation()
{ }

#line 112 "annotation.cpp"

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

Ptree*
make_static_leaf(const char* txt)
{
    return new Leaf(const_cast<char*>(txt), std::strlen(txt));
}

#line 120 "annotation.cpp"

Ptree*
make_dup_leaf(const char* txt)
{
    char* ntxt = new char[std::strlen(txt)+1];
    std::strcpy(ntxt, txt);
    Token tmp_tok = { ntxt, std::strlen(txt), ntName };
    return new Leaf(tmp_tok);
}

#line 129 "annotation.cpp"

Ptree*
make_dup_leaf(std::string txt)
{
    return make_dup_leaf(txt.c_str());
}

#line 135 "annotation.cpp"

Annotated<LeafThis>*
make_this(Type type)
{
    Token tmp_tok = { "this", 4, THIS };
    LeafThis tmp_leaf(tmp_tok);
    return new Annotated<LeafThis>(type.make_pointer_type().with_qualifier(Type::q_Const),
                                   0,
                                   tmp_leaf);
}

#line 145 "annotation.cpp"

Annotated<LeafName>*
make_name(const char* txt, Type type, Symbol* sym)
{
    char* ntxt = new char[std::strlen(txt)+1];
    std::strcpy(ntxt, txt);
    Token tmp_tok = { ntxt, std::strlen(txt), ntName };
    LeafName tmp_leaf(tmp_tok);

    return new Annotated<LeafName>(type, sym, tmp_leaf);
}

#line 156 "annotation.cpp"

Annotated<LeafName>*
make_name(std::string str, Type type, Symbol* sym)
{
    return make_name(str.c_str(), type, sym);
}

#line 162 "annotation.cpp"

Annotated<LeafName>*
make_name(Function_signature* fsig)
{
    std::string s = fsig->get_name();
    if (!s.length())
        s = fsig->get_function()->get_name();

    return make_name(s.c_str(),
                     fsig->get_call_type(),
                     fsig);
}

#line 174 "annotation.cpp"

Annotated<LeafName>*
make_name(Variable_symbol* vsym)
{
    return make_name(vsym->get_name().c_str(),
                     vsym->get_type(),
                     vsym);
}

#line 182 "annotation.cpp"

Annotated<PtreeFstyleCastExpr>*
make_cast_expr_unchecked(Ptree* expr, const Type& target_type)
{
    /* PtreeFstyleCastExpr:
       [type ( [expr] )] */
    return new Annotated<PtreeFstyleCastExpr>(target_type,
                                              0,
                                              (char*) "", /* encoded type */
                                              make_name(target_type.get_encoded_type().c_str(),
                                                        target_type, 0),
                                              Ptree::List(make_static_leaf("("),
                                                          expr,
                                                          make_static_leaf(")")));
}

#line 197 "annotation.cpp"

Annotated<PtreeFstyleCastExpr>*
make_cast_expr(Ptree* expr, Type target_type)
{
    assert(target_type.is_valid());
    assert(!target_type.is_class_type());
    return make_cast_expr_unchecked(expr, target_type);
}

#line 206 "annotation.cpp"

Annotated<PtreeFstyleCastExpr>*
make_derived_to_base_cast(Ptree* expr, Type target_type)
{
    assert(target_type.is_valid());
    assert(target_type.is_class_type());
    return make_cast_expr_unchecked(expr, target_type);
}

#line 216 "annotation.cpp"

Annotated<PtreeCommaExpr>*
make_comma_expr(Ptree* lhs, Ptree* rhs)
{
    Annotation* lanno = dynamic_cast<Annotation*>(lhs);
    Annotation* ranno = dynamic_cast<Annotation*>(rhs);
    assert(lanno);
    assert(ranno);

    if (PtreeCommaExpr* cx = dynamic_cast<PtreeCommaExpr*>(rhs)) {
        lhs = make_comma_expr(lhs, rhs->First());
        rhs = rhs->Third();
        ranno = dynamic_cast<Annotation*>(rhs);
        assert(ranno);
    }

    return new Annotated<PtreeCommaExpr>(ranno->get_type(),
                                         0,
                                         lhs,
                                         Ptree::List(make_static_leaf(","),
                                                     rhs));
}

#line 241 "annotation.cpp"

Annotated<PtreeDeclaration>*
make_declaration(Variable_symbol* vsym)
{
    /* format of a variable declaration is:
       "a b;"       => Declaration@[null TYPE [Declarator@[NAME]] ;]
       "a b(args);" => Declaration@[null TYPE [Declarator@[NAME [( args )]]] ;]
       "a b = x;"   => Declaration@[null TYPE [Declarator@[NAME = EXPR]]]

       We don't generate initializers; those can be snarfed from the
       actual variable symbol if needed. */

    Encoding tmp_enc;

    PtreeDeclarator* decl =
        new PtreeDeclarator(Ptree::List(make_dup_leaf(vsym->get_name())),
                            tmp_enc);

    return new Annotated<PtreeDeclaration>(vsym->get_type(),
                                           vsym,
                                           0 /* storage class etc. */,
                                           Ptree::List(make_dup_leaf(vsym->get_type().get_encoded_type()),
                                                       decl,
                                                       make_static_leaf(";")));
}

#line 266 "annotation.cpp"

void
fill_in_overload_annotation(Ptree* tree, Symbol* sym, Type t)
{
    Annotation* anno = dynamic_cast<Annotation*>(tree);
    assert(anno);
    anno->set_type(t);

    if (PtreeCommaExpr* cx = dynamic_cast<PtreeCommaExpr*>(tree))
        fill_in_overload_annotation(cx->Third(), sym, t);
    else
        anno->set_symbol(sym);
}

#line 281 "annotation.cpp"

/*********************** Annotated_funcall_maker *******************************/


Annotated_funcall_maker::Annotated_funcall_maker(Ptree* function,
                                                 Type result_type)
    : function(function), result_type(result_type), tree(0)
{ }

#line 289 "annotation.cpp"


Annotated_funcall_maker::~Annotated_funcall_maker()
{ }

#line 293 "annotation.cpp"

void
Annotated_funcall_maker::add_arg(Ptree* arg)
{
    if (!tree) {
        tree = new NonLeaf(arg, 0);
    } else {
        tree = Ptree::Snoc(tree, make_static_leaf(","));
        tree = Ptree::Snoc(tree, arg);
    }
}

#line 304 "annotation.cpp"

Ptree*
Annotated_funcall_maker::make_funcall()
{
    /* Function call leaf:
         [function ( null )]
         [function ( [a , b , ...] ) */
    if (PtreeCommaExpr* cx = dynamic_cast<PtreeCommaExpr*>(function)) {
        compile_warning("calling a comma expression", cx);
        return make_comma_expr(function->First(),
                               new Annotated<PtreeFuncallExpr>(result_type,
                                                               0,
                                                               function->Third(),
                                                               Ptree::List(make_static_leaf("("),
                                                                           tree,
                                                                           make_static_leaf(")"))));
    } else {
        return new Annotated<PtreeFuncallExpr>(result_type,
                                               0,
                                               function,
                                               Ptree::List(make_static_leaf("("),
                                                           tree,
                                                           make_static_leaf(")")));
    }
}

#line 329 "annotation.cpp"

/* Handy function */
Ptree*
make_unary_funcall(Ptree* function, Type result, Ptree* arg)
{
    Annotated_funcall_maker afm(function, result);
    afm.add_arg(arg);
    return afm.make_funcall();
}

#line 338 "annotation.cpp"

static const char*
unmangle(const char* name)
{
    if (*name == 't') {
        /* t<len><name>1Z<len> */
        int num = 0;
        ++name;
        while (*name >= '0' && *name <= '9')
            num = 10*num + *name++ - '0';
        name += num + 2;
    }
    while (*name >= '0' && *name <= '9')
        ++name;
    return name;
}
#line 354 "annotation.cpp"

/* Just a hack to save typing :-) */
#define COLOR_(c) #c
#line 357 "annotation.cpp"
#define COLOR(c) (colors ? "\033[" COLOR_(c) "m" : "")
#line 358 "annotation.cpp"
#define cBlack 30
#line 359 "annotation.cpp"
#define cRed 31
#line 360 "annotation.cpp"
#define cGreen 32
#line 361 "annotation.cpp"
#define cYellow 33
#line 362 "annotation.cpp"
#define cBlue 34
#line 363 "annotation.cpp"
#define cMagenta 35
#line 364 "annotation.cpp"
#define cCyan 36
#line 365 "annotation.cpp"
#define cWhite 37

#line 366 "annotation.cpp"

/* meta information -> black
   names -> red
   types -> green
   node content -> blue */
void
print_annotated_tree(std::ostream& out, std::string indent, Ptree* tree, bool colors)
{
    if (!tree) {
        out << indent << "null";
        return;
    }
    Annotation* an = dynamic_cast<Annotation*>(tree);
    out << indent;
    if (an) {
        out << "[";
        if (Symbol* sym = an->get_symbol()) {
            std::string n = sym->get_name();
            if (n.length())
                out << COLOR(cRed) << n << COLOR(0);
            else
                out << "unnamed";
        } else {
            out << "no symbol";
        }
        Type t = an->get_type();
        if (t.is_valid()) {
            out << ", " << COLOR(cGreen) << t.make_pointer_type().get_encoded_type().substr(1)
                << COLOR(0);
        }
        if (an->has_flag(Annotation::af_DirectCall))
            out << ", direct";
        out << "] ";
    }
    if (tree->IsLeaf()) {
        out << COLOR(cBlue) << tree->ToString() << COLOR(0);
        if (Symbol_table::has_dump_flag('a'))
            out << " @" << (void*)tree;
    } else {
        out << unmangle(typeid(*tree).name());
        if (Symbol_table::has_dump_flag('a'))
            out << " @" << (void*)tree;
        while (tree) {
            out << "\n";
            print_annotated_tree(out, indent + "  ", tree->Car(), colors);
            tree = tree->Cdr();
        }
    }
}

---