---

function.h

Go to the documentation of this file.

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

#ifndef function_h
#define function_h

#include <vector>
#include "symbol_table.h"
#include "type_rep.h"
#include "symbol_name.h"

//
// INTERFACE definition follows 
//


class Class_symbol;
class Block_scope;
class Function_symbol;
class Variable_symbol;
class Function_signature : public Symbol {
    /* the declared type, i.e. the type of the prototype */
    Type                      proto_type;
    /* the type of the implicit object parameter */
    Type                      this_type;
    /* the type used when calling this function. */
    Type                      call_type;

    Storage_class_specifier   storage_spec;
    Function_specifier_set    function_spec;
    bool                      builtin;
    bool                      generated;
    Function_symbol*          backlink;
    Ptree*                    definition;
    Ptree*                    initializers;

 public:
    typedef std::vector<Variable_symbol*> Par_vec;

 private:
    Par_vec                   parameters;

public:  
  /*************************** Function_signature **************************/
  
  Function_signature(Type t, Type this_type, Type call_type, Storage_class_specifier sc, Function_specifier_set f, Function_symbol* backlink);
  
  static Function_signature* make_builtin(Type t);
  
  Type get_return_type() const;
  
  Type get_proto_type() const;
  
  Type get_call_type() const;
  
  Type get_this_type() const;
  
  bool has_pointer_type(Type t) const;
  
  Type get_pointer_type() const;
  
  Storage_class_specifier get_storage_specifier() const;
  
  Function_specifier_set get_function_specifiers() const;
  
  void merge_fspec(Function_specifier_set fspec);
  
  bool is_builtin() const;
  
  void set_builtin();
  
  bool is_generated() const;
  
  void set_generated();
  
  Function_symbol* get_function() const;
  
  Ptree* get_body() const;
  
  Ptree* get_initializers() const;
  
  void set_body(Ptree* tree, Ptree* init);
  
  Function_signature::Par_vec::const_iterator par_begin() const;
  
  Function_signature::Par_vec::const_iterator par_end() const;
  
  void add_parameter(Variable_symbol* vsym);
  
  Symbol::Kind get_kind() const;
  
  void dump(std::ostream& os);
};

class Function_symbol : public Symbol {
    typedef std::vector<Function_signature*> Sig_vec;
    Sig_vec            signatures;
    Abstract_scope*    declared_scope;
    Symbol_name::Kind  fun_kind;

 public:
    enum Add_arg {
        must_be_declared,
        must_be_new,
        may_be_anything
    };
    typedef Sig_vec::const_iterator Sig_it;
    Sig_it sig_begin() const { return signatures.begin(); }
    Sig_it sig_end() const { return signatures.end(); }

    Symbol_name::Kind get_function_kind() const { return fun_kind; }

public:  
  /**************************** Function_symbol ****************************/
  Function_symbol(Abstract_scope* declared_scope, Symbol_name::Kind fun_kind);
  
  Abstract_scope* get_declared_scope() const;
  
  Function_symbol::Kind get_kind() const;
  
  void fill_in_mangled_names(bool ignore_if_one);
  
  Function_signature* add_signature(Type t, Type this_type, Storage_class_specifier sc, Function_specifier_set f, Add_arg what_to_do);
  
  bool is_overloaded() const;
  
  Type get_type() const;
  
  Function_signature* get_nonoverloaded_signature() const;
  
  Function_signature* get_function_signature(Type type, bool* ambig) const;
  
  void dump(std::ostream& os);
};

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



inline Type
Function_signature::get_proto_type() const
{
    return proto_type;
}


inline Type
Function_signature::get_call_type() const
{
    return call_type;
}


inline Type
Function_signature::get_this_type() const
{
    return this_type;
}


inline Storage_class_specifier
Function_signature::get_storage_specifier() const
{
    return storage_spec;
}


inline Function_specifier_set
Function_signature::get_function_specifiers() const
{
    return function_spec;
}


inline bool
Function_signature::is_builtin() const
{
    return builtin;
}


inline void
Function_signature::set_builtin()
{
    builtin = true;
}


inline bool
Function_signature::is_generated() const
{
    return generated;
}


inline void
Function_signature::set_generated()
{
    generated = true;
    if (!is_declared())
        set_status(st_Declared);
}


inline Function_symbol*
Function_signature::get_function() const
{
    return backlink;
}


inline Ptree*
Function_signature::get_body() const
{
    assert(is_defined());
    return definition;
}


inline Ptree*
Function_signature::get_initializers() const
{
    assert(is_defined());
    return initializers;
}


inline Abstract_scope*
Function_symbol::get_declared_scope() const
{
    return declared_scope;
}


inline Type
Function_symbol::get_type() const
{
    return get_nonoverloaded_signature()->get_proto_type();
}

#endif // function_h

---