il/function_call_expression.h

#ifndef FUNCTION_CALL_EXPRESSION_H_
#define FUNCTION_CALL_EXPRESSION_H_

#include "expression.h"
#include <vector>

using namespace std;

namespace il
{

class function_call_expression : public expression
{
    friend class boost::serialization::access;

    template<class Archive>
    void save(Archive & ar, const unsigned int version) const
    {
        ar & boost::serialization::base_object<il::expression>(*this);
        ar & fn_name;
        ar & ns;
        ar & fn_signature;
        ar & args;
        ar & is_no_return;
        ar & is_alloc;
        ar & operator_new;
        ar & is_dealloc;
        ar & constructor;
        ar & destructor;
    }

    template<class Archive>
    void load(Archive & ar, const unsigned int version)
    {
        ar & boost::serialization::base_object<il::expression>(*this);
        ar & fn_name;
        ar & ns;
        ar & fn_signature;
        type::register_loaded_typeref(&fn_signature);
        ar & args;
        ar & is_no_return;
        ar & is_alloc;
        ar & operator_new;
        ar & is_dealloc;
        ar & constructor;
        ar & destructor;
    }

    BOOST_SERIALIZATION_SPLIT_MEMBER()

private:
        string fn_name;
        namespace_context ns;
        type* fn_signature;
        vector<expression*> args;
        bool is_no_return;
        bool is_alloc;
        bool operator_new;
        bool is_dealloc;
        bool constructor;
        bool destructor;

        
        expression *vtable_lookup_expr;
        
        long int vtable_index;


public:
        function_call_expression();
        function_call_expression(string fn_name,
                                                         namespace_context ns,
                                 type *fn_signature,
                                 vector<expression *> &args,
                                 type *t,
                                 bool is_no_return,
                                 bool is_alloc,
                                 bool is_operator_new,
                                 bool is_dealloc,
                                 bool is_constructor,
                                 bool is_destructor,
                                 expression *vtable_lookup_expr,
                                 long int vtable_index,
                                 location loc);
        
        virtual string to_string() const;

        virtual string get_function();

        virtual type* get_signature();

        const namespace_context & get_namespace();

        virtual vector<expression*>& get_arguments();

        bool is_exit_function();

        bool is_allocator();
        
        bool is_operator_new();

        bool is_deallocator();

        bool is_constructor();


        bool is_destructor();


        bool is_call_to_virtual() const;

        bool has_return();

        expression *get_vtable_lookup_expr();

        int get_vtable_index();

        virtual ~function_call_expression();
};

}

#endif /*FUNCTION_CALL_EXPRESSION_H_*/

---