---

function_body.cc

Go to the documentation of this file.

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

#include "function_body.h"
#include "function_body_i.h"


#line 103 "function_body.cpp"
/******************************* Functions *******************************/

static Ptree*
process_initializers(Function_signature* fsig, Block_scope* scope, Ptree* tree);

#line 50 "function_body.cpp"

Function_body_queue::Function_body_queue()
    : first(0), last(0)
{ }

#line 56 "function_body.cpp"

void
Function_body_queue::add_function(Function_signature* fsig,
                                  Block_scope* scope,
                                  Ptree* tree,
                                  Ptree* init)
{
    assert(fsig);
    assert(scope);
    assert(tree);
    assert(!init || fsig->get_function()->get_function_kind() == Symbol_name::k_Constructor);

    Function_body_node* p = new Function_body_node(fsig, scope, tree, init);
    if (first)
        last->next = p;
    else
        first = p;
    last = p;
}

#line 80 "function_body.cpp"

Function_body_node*
Function_body_queue::pop()
{
    Function_body_node* rv = first;
    if (first) {
        first = first->next;
        if (!first)
            last = 0;
    }
    return rv;
}

#line 92 "function_body.cpp"

void
Function_body_queue::process()
{
    while (Function_body_node* p = pop()) {
        process_function_body(p->fsig, p->scope, p->tree, p->init);
        delete p;
    }
}

#line 102 "function_body.cpp"

/******************************* Functions *******************************/

static Ptree*
process_initializers(Function_signature* fsig, Block_scope* scope, Ptree* tree)
{
    /* cut off the ":" */
    if (tree) {
        expect_ptree(tree->Car(), ':');
        tree = tree->Cdr();
    }

    /* the scopes we work in */
    Abstract_scope* class_scope = fsig->get_function()->get_declared_scope();
    Class_symbol* class_sym = downcast<Class_symbol*>(fsig->get_this_type().get_type_symbol());

    /* what we do: we parse the initializer into an array. Then, we
       gather them up in the order in which they'll be executed and
       null them out. If some remain, we have a bug. */
    std::vector<std::pair<Symbol*, Ptree*> > inits;
    for (Ptree* p = tree; p; (p = p->Cdr()) && (p = p->Cdr())) {
        Ptree* ele = p->Car();
        expect_ptree(ele->Second(), '(');
        expect_ptree(ele->Nth(3), ')');
        // FIXME: 12.6.2p2 says first look into class_scope, then
        // the scope in which the ctor is defined
        Symbol_pair sp = Symbol_name(ele->First(), class_scope, false).lookup_for_use(false);

        Symbol* the_sym = 0;
        if (Class_symbol* csym = dynamic_cast<Class_symbol*>(sp.tag))
            the_sym = csym;
        else if (Variable_symbol* vsym = dynamic_cast<Variable_symbol*>(sp.untag))
            the_sym = vsym;
        else if (Typedef_symbol* tdsym = dynamic_cast<Typedef_symbol*>(sp.untag)) {
            Type t = tdsym->get_type();
            if (t.is_class_type())
                the_sym = t.get_type_symbol();
        }

        if (!the_sym)
            compile_error("don't know what to do with name `" + std::string(ele->First()->ToString()) + "` in an initializer");

        inits.push_back(std::make_pair(the_sym, ele->Cdr()));
    }

    /* Now we have all the initializers. What do we want to initialize? */
    std::vector<Symbol*> want;
    for (Class_symbol::bases_t::const_iterator i = class_sym->vbc_begin(); i != class_sym->vbc_end(); ++i)
        want.push_back(*i);
    for (Class_symbol::bases_t::const_iterator i = class_sym->base_begin(); i != class_sym->base_end(); ++i)
        want.push_back(*i);
    for (Class_symbol::members_t::const_iterator i = class_sym->mem_begin(); i != class_sym->mem_end(); ++i)
        if ((*i)->is_member_variable())
            want.push_back(*i);

    /* Let's boogie. */
    Ptree* output_list = 0;
    unsigned last_used = 0;
    for (unsigned i = 0; i < want.size(); ++i) {
        /* first, look up the corresponding initializer and strike it out. */
        Ptree* the_init = 0;
        for (unsigned j = 0; j < inits.size(); ++j) {
            if (inits[j].first == want[i]) {
                if (the_init) {
                    compile_warning("multiple initializers for `" + want[i]->get_name() + "'", the_init);
                } else {
                    if (last_used > j)
                        compile_warning("initializers will be re-ordered to match initialisation rules", the_init);
                    the_init = inits[j].second;
                    last_used = j;
                }
                inits[j].first = 0;
            }
        }

        /* do it. */
        Ptree *output_init, *output_name;
        if (Class_symbol* csym = dynamic_cast<Class_symbol*>(want[i])) {
            output_init = Init_handler(scope, the_init, false).process_initializer(csym->get_type());
            output_name = make_name(csym->get_name(), csym->get_type(), csym);
        } else if (Variable_symbol* vsym = dynamic_cast<Variable_symbol*>(want[i])) {
            output_init = Init_handler(scope, the_init, false).process_initializer(vsym->get_type());
            if (!output_init)
                compile_warning("member `" + vsym->get_name() + "' not initialized", tree);
            output_name = make_name(vsym);
        } else {
            assert(!"game over");
        }

        /* build output tree */
        output_list = Ptree::Snoc(output_list,
                                  Ptree::List(output_name,
                                              make_static_leaf("="),
                                              output_init));
    }

    /* everything done? */
    for (unsigned i = 0; i < inits.size(); ++i)
        if (inits[i].first)
            compile_error("unexpected initializer for `" + inits[i].first->get_name() + "'");

    return output_list;
}

#line 212 "function_body.cpp"

void
process_function_body(Function_signature* fsig, Block_scope* scope,
                      Ptree* tree, Ptree* init)
{
    if (fsig->get_storage_specifier() == s_Member)
        scope->set_this_type(fsig->get_this_type());
    else
        scope->set_this_type(Type());

    // maybe it's a constructor
    if (fsig->get_function()->get_function_kind() == Symbol_name::k_Constructor)
        init = process_initializers(fsig, scope, init);
    else
        assert(!init);

    // this assumes that the tree is a PtreeBlock or a simple statement
    Annotator anno(&Source::instance(), scope);
    anno.visit_stmt_or_block(tree);
    fsig->set_body(anno.get_output(), init);
}

---