---

function.cc

Go to the documentation of this file.

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

#include "function.h"
#include "function_i.h"


#line 69 "function.cpp"

/**************************** Function_symbol ****************************/


Function_symbol::Function_symbol(Abstract_scope* declared_scope,
                                 Symbol_name::Kind fun_kind)
    : declared_scope(declared_scope), fun_kind(fun_kind)
{
    /* avoid the wording "undefined function" in dumps. A function
       signature is not an object. */
    set_status(st_Defined);
}

#line 87 "function.cpp"

Function_symbol::Kind
Function_symbol::get_kind() const
{
    return k_Function;
}

#line 93 "function.cpp"

void
Function_symbol::fill_in_mangled_names(bool ignore_if_one)
{
    if (ignore_if_one && signatures.size() == 1) {
        if (signatures.front()->get_name().length() == 0)
            signatures.front()->set_name(get_name(), get_basename().length());
        return;
    }
    for (Sig_it i = signatures.begin(); i != signatures.end(); ++i) {
        if ((*i)->get_name().length() == 0) {
            std::string s = Symbol_name::get_mangled_function_name(get_basename(),
                                                                   (*i)->get_proto_type(),
                                                                   (*i)->get_this_type());
            (*i)->set_name(declared_scope->get_unique_name(s), s.length());
        }
    }
}

#line 111 "function.cpp"

Function_signature*
Function_symbol::add_signature(Type t, Type this_type,
                               Storage_class_specifier sc,
                               Function_specifier_set f,
                               Add_arg what_to_do)
{
    assert(sc == s_Extern || sc == s_Static || sc == s_Member || sc == s_None);

    /* qualifiers of t actually apply to this_type, i.e.
       `void(int) const' in `Foo' actually is `void(int)' in `const Foo' */
    if (this_type.is_valid()) {
        if (t.is_qualified(Type::q_Restrict))
            compile_error("restrict not allowed as function type qualifier");
        this_type.copy_qualifiers(t);
        t = t.get_unqualified_type();
    } else {
        if (t.is_qualified())
            compile_error("non-member function can't be qualified");
    }

    /* look up function signature */
    std::string tsig = t.get_function_signature();
    Function_signature* found_sig = 0;

    for (Sig_vec::iterator i = signatures.begin(); i != signatures.end(); ++i) {
        Function_signature* sig = *i;
        if (sig->get_proto_type().get_function_signature() == tsig)
            if (!found_sig || sig->get_this_type() == this_type)
                found_sig = sig;
    }

    if (found_sig) {
        /* we already have a function which takes the same parameters */
        if (found_sig->get_storage_specifier() == s_Member) {
            /* the existing function is a member. This one must
               be a member, too; maybe with different this_type. */
            if (sc != s_None && sc != s_Member)
                compile_error("new static function collides with existing member");
            assert(this_type.is_valid());
            if (this_type == found_sig->get_this_type()) {
                if (what_to_do == must_be_new)
                    compile_error("function already declared");
                found_sig->merge_fspec(f);
                return found_sig;
            }
            /* fallthrough to creation of new signature */
        } else {
            /* the existing function is not a member. this_type is
               irrelevant */
            if (this_type.is_valid() && this_type.is_qualified())
                compile_error("static functions may not be qualified");
            if (sc == s_Member)
                compile_error("new member function collides with existing static function");
            if (what_to_do == must_be_new)
                compile_error("function already declared");
            found_sig->merge_fspec(f);
            return found_sig;
        }
    }

    if (what_to_do == must_be_declared)
        compile_error("can't introduce new signatures here");

    /* okay, it's a new function */
    Type call_type;
    if (sc == s_None)
        sc = s_Extern;

    if (sc != s_Member) {
        // FIXME: check function kind?
        this_type = Type();
        call_type = t;
    } else {
        if (get_function_kind() == Symbol_name::k_Constructor) {
            // FIXME: HACK HACK HACK. Replace the return type.
            std::string s = t.get_encoded_type();
            s.erase(s.length()-1);
            call_type = Type(s);
        } else if (get_function_kind() == Symbol_name::k_Destructor) {
            call_type = make_unary_function_type(this_type.make_reference_type(),
                                                 void_type);
        } else if (get_function_kind() == Symbol_name::k_Conversion) {
            call_type = make_unary_function_type(this_type.make_reference_type(),
                                                 t.get_return_type());
        } else {
            call_type = t.with_first_arg(this_type.make_reference_type());
        }
    }

    Function_signature* sig = new Function_signature(t, this_type,
                                                     call_type,
                                                     sc, f, this);

    signatures.push_back(sig);
    return sig;
}

#line 218 "function.cpp"

bool
Function_symbol::is_overloaded() const
{
    /* only count declared functions:
         void foo() {
            extern void foo(int);
         }
         void bar() {
            foo;           // foo is not an overloaded function here
         }                 // although we know the second signature
    */
    Sig_vec::size_type n = 0;
    for (Sig_vec::const_iterator i = signatures.begin(); i != signatures.end(); ++i)
        if ((*i)->is_declared())
            ++n;
    return n != 1;
}

#line 244 "function.cpp"

Function_signature*
Function_symbol::get_nonoverloaded_signature() const
{
    assert(!is_overloaded());
    for (Sig_vec::const_iterator i = signatures.begin(); i != signatures.end(); ++i)
        if ((*i)->is_declared())
            return *i;
    assert(0);
}

#line 256 "function.cpp"

Function_signature*
Function_symbol::get_function_signature(Type type, bool* ambig) const
{
    assert(type.get_kind() == Type::k_Pointer || type.get_kind() == Type::k_Member);
    Function_signature* p = 0;
    for (Sig_vec::const_iterator i = signatures.begin(); i != signatures.end(); ++i) {
        if ((*i)->is_declared() && (*i)->has_pointer_type(type)) {
            if (p) {
                if (ambig)
                    *ambig = true;
                return 0;       // ambiguous
            } else {
                p = *i;
            }
        }
    }
    if (ambig)
        *ambig = false;
    return p;
}

#line 282 "function.cpp"

void
Function_symbol::dump(std::ostream& os)
{
    Symbol::dump(os);
    for (Sig_vec::iterator i = signatures.begin(); i != signatures.end(); ++i) {
        os << "\n  " << (*i)->get_name() << ":\n  ";
        (*i)->dump(os);
    }
}

#line 292 "function.cpp"

/*************************** Function_signature **************************/

Function_signature::Function_signature(Type t, Type this_type,
                                       Type call_type,
                                       Storage_class_specifier sc,
                                       Function_specifier_set f,
                                       Function_symbol* backlink)
    : proto_type(t), this_type(this_type),
      call_type(call_type),
      storage_spec(sc), function_spec(f),
      builtin(false), generated(false), backlink(backlink), definition(0)
{
    assert(this_type.is_valid() == (sc == s_Member));
}

#line 315 "function.cpp"

Function_signature*
Function_signature::make_builtin(Type t)
{
    Function_signature* fsig = new Function_signature(t, Type(), t, s_Extern, f_None, 0);
    fsig->set_name("builtin", 7);
    fsig->set_builtin();
    return fsig;
}

#line 327 "function.cpp"

Type
Function_signature::get_return_type() const
{
    return get_proto_type().get_return_type();
}

#line 356 "function.cpp"

bool
Function_signature::has_pointer_type(Type t) const
{
    if (this_type.is_valid()) {
        /* this is a member function */
        assert(storage_spec == s_Member);
        /* target must be pointer to member */
        if (t.get_kind() != Type::k_Member || t.get_member_type().get_kind() != Type::k_Function)
            return false;
        /* signature must fit */
        if (t.get_member_type() != proto_type)
            return false;
        /* qualifications on class type must fit:
           "void (c::*pmf)() = &c::const_mf" works,
           "void (c::*pmf)() const = &c::nonconst_mf" doesn't */
        Type cl = t.get_class_type();
        if (cl.is_more_qualified_than(this_type))
            return false;
        /* derivation:
           "void (derived::*pmf)() = &base::mf" */
        return cl.get_unqualified_type() == this_type.get_unqualified_type()
            || downcast<Class_symbol*>(this_type.get_type_symbol())->is_unique_base_class_of(downcast<Class_symbol*>(cl.get_type_symbol()));
    } else {
        /* this is a static function */
        if (t.get_kind() != Type::k_Pointer)
            return false;
        return t.get_basis_type().is_same_unqualified_type(proto_type);
    }
}

#line 391 "function.cpp"

Type
Function_signature::get_pointer_type() const
{
    if (this_type.is_valid()) {
        return this_type.make_member_type(proto_type);
    } else {
        return proto_type;
    }
}

#line 416 "function.cpp"

void
Function_signature::merge_fspec(Function_specifier_set fspec)
{
    if (fspec & ~f_Inline)
        compile_error("only the `inline' specifier can be added to a declared function");
    function_spec |= fspec;
}

#line 483 "function.cpp"

void
Function_signature::set_body(Ptree* tree, Ptree* init)
{
    set_status(st_Defined);
    definition = tree;
    initializers = init;
}

#line 493 "function.cpp"

Function_signature::Par_vec::const_iterator
Function_signature::par_begin() const
{
    return parameters.begin();
}

#line 499 "function.cpp"

Function_signature::Par_vec::const_iterator
Function_signature::par_end() const
{
    return parameters.end();
}

#line 505 "function.cpp"

void
Function_signature::add_parameter(Variable_symbol* vsym)
{
    assert(vsym->get_type().is_same_unqualified_type(get_proto_type().get_function_arg(parameters.size())));
    parameters.push_back(vsym);
}

#line 512 "function.cpp"

Symbol::Kind
Function_signature::get_kind() const
{
    return k_Function;
}

#line 518 "function.cpp"

void
Function_signature::dump(std::ostream& os)
{
    Symbol::dump(os);
    os << ", type is `" << proto_type.get_human_readable_type()
       << "'\n    storage: " << get_storage_specifier_name(storage_spec)
       << ", function specifiers: " << get_function_specifier_name(function_spec)
       << ", class type: ";
    if (this_type.is_valid())
        os << "`" << this_type.get_human_readable_type() << "'";
    else
        os << "(none)";
    if (is_generated())
        os << ", synthesized";
    if (Symbol_table::has_dump_flag('b')) {
        if (initializers) {
            os << "\n    Member Initializers:\n";
            print_annotated_tree(os, "    | ", initializers, Symbol_table::has_dump_flag('c'));
        }
        if (definition) {
            os << "\n    Body:\n";
            print_annotated_tree(os, "    | ", definition, Symbol_table::has_dump_flag('c'));
        }
    }
}

---