/home/chris/Projects/eval/execution_context.hpp

Go to the documentation of this file.

// Copyright (C) 2008 Christian Hoermann (0oo0oo0.c@gmail.com)
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)



#ifndef EVAL_EXECUTION_CONTEXT_H
#define EVAL_EXECUTION_CONTEXT_H

#include <typeinfo>
#include <stdexcept>
#include <vector>
#include <map>
#include <utility>
#include <cstring>

#include <boost/static_assert.hpp>
#include <boost/shared_array.hpp>
#include <boost/type_traits/is_reference.hpp>

#include "fwrap.hpp"


namespace eval
{
    class execution_failure : public std::invalid_argument
    {
    public:
        explicit execution_failure(const std::string& err)
          : std::invalid_argument(err)
        {
        }
    };

    class ambiguous_overload_exception : public execution_failure
    {
    public:
        explicit ambiguous_overload_exception(const std::string& err)
          : execution_failure("eval::ambiguous_overload_exception: '" + err + "'")
        {
        }
    };

    class no_matching_function_exception : public execution_failure
    {
    public:
        explicit no_matching_function_exception(const std::string& err)
          : execution_failure("eval::no_matching_function_exception: method or function"
                              " call failed '" + err + "'")
        {
        }
    };

    class unknown_type_exception : public execution_failure
    {
    public:
        explicit unknown_type_exception(const std::string& type_name)
          : execution_failure("eval::unknown_type_exception: Unknown type '" + type_name + "'")
        {
        }
    };

    class undefined_global_exception : public execution_failure
    {
    public:
        explicit undefined_global_exception(const std::string& name)
          : execution_failure("eval::undefined_global_exception: Unknown global '"
                              + name + "'")
        {
        }
    };

    class redefined_global_exception : public execution_failure
    {
    public:
        explicit redefined_global_exception(const std::string& name)
          : execution_failure("eval::redefined_global_exception: global '" + name
                              + "' already defined")
        {
        }
    };



    class bad_extended_val_cast : public execution_failure
    {
    public:
        bad_extended_val_cast(const std::string& type_from, const std::string& type_to)
          : execution_failure("eval::bad_extended_val_cast: from '" + type_from + "' to '"
                              + type_to + "'")
        {
        }
    };


    namespace detail
    {
        struct type_info_ptr_compare
        {
            bool operator()(const std::type_info *lhs, const std::type_info *rhs) const
            {
                return lhs->before(*rhs);
            }
        };

        class object_method_store
        {
        public:
            typedef std::multimap<std::string, fwrap>::const_iterator const_method_it_t;
            typedef std::multimap<std::string, fwrap>::iterator method_it_t;

            object_method_store(const std::string& obj_name)
              : _obj_name(obj_name)
            {
            }

            std::string get_obj_name() const
            {
                return _obj_name;
            }

            void add_method(const std::string& method_name, const fwrap& m)
            {
                _methods.insert(std::pair<std::string, fwrap>(method_name, m));
            }

            std::pair<const_method_it_t, const_method_it_t>
                                                  get_methods(const std::string& method_name) const
            {
                return _methods.equal_range(method_name);
            }

            void add_static_method(const std::string& static_method_name, const fwrap& m)
            {
                _static_methods.insert(std::pair<std::string, fwrap>(static_method_name, m));
            }

            std::pair<const_method_it_t, const_method_it_t>
                                           get_static_methods(const std::string& method_name) const
            {
                return _static_methods.equal_range(method_name);
            }

            void delete_methods(const std::string& method_name)
            {
                std::pair<method_it_t, method_it_t> remove_range;
                
                remove_range = _methods.equal_range(method_name);
                _methods.erase(remove_range.first, remove_range.second);

                remove_range = _static_methods.equal_range(method_name);
                _static_methods.erase(remove_range.first, remove_range.second);
            }
        private:
            std::string _obj_name;
            std::multimap<std::string, fwrap> _methods;
            std::multimap<std::string, fwrap> _static_methods;
        };

        class type_info_conversion_store
        {
        public:
            type_info_conversion_store(const std::type_info *from, const std::type_info *to)
              : _from(from), _to(to)
            {
            }

            bool operator<(const type_info_conversion_store& rhs) const
            {
                return *_from == *rhs._from ? _to->before(*rhs._to) : _from->before(*rhs._from);
            }
        
        private:
            const std::type_info * _from;
            const std::type_info * _to;
        };

        enum conversion_rank {
            CONVERSION_EXACT_MATCH = 300,
            CONVERSION_QUALIFICATION = 200,
            CONVERSION_OTHER_CONVERSION = 100,
            CONVERSION_IMPOSSIBLE = -1
        };


        template<typename Iterator1, typename Iterator2>
        bool strictly_greater_or_equal_all(Iterator1 begin1, Iterator1 end1, Iterator2 begin2)
        {
            bool elements_all_equal = true;
            for( ; begin1 != end1; ++begin1, ++begin2)
            {
                if(*begin1 < *begin2)
                {
                    return false;
                }
                else if(*begin1 > *begin2)
                {
                    elements_all_equal = false;
                }
            }
            return !elements_all_equal;
        }




    } // namespace detail

    class execution_context
    {
    public:
        typedef val(*val_convert_t)(val& v);

        execution_context()
          : _initialized(false)
        {
        }

        virtual void register_all()
        {
            if(!_initialized)
            {
                _initialized = true;
                this->register_functions();
                this->register_methods_and_ctors();
                this->register_types();
                this->register_conversions();
            }
        }

        bool point_to_same_obj(val& lhs, val& rhs) const;

        template<typename DesiredT>
        DesiredT *extended_val_cast_ptr(val& v) const;
        
        template<typename DesiredT>
        DesiredT extended_val_cast_value(val& v) const;
       
              
        val val_cast_conversion_string(val& v, const std::string& desired_type,
                                       bool can_use_temp) const;

        val call(fwrap& f, fwrap_args& args);
   
        val call_function(const std::string& fn_name, fwrap_args& args);  

        val call_method(const std::string& m_name, fwrap_args& args);
       
        val call_function_or_method(const std::string& name, fwrap_args& args);

        val& get_global(const std::string& name);

        const val& get_global(const std::string& name) const;

        void add_global(const std::string& name, const val& v);

        val& operator[](const std::string& name);

        void clear_globals();

        virtual ~execution_context();
       
    protected:
        virtual void register_functions()
        {
        }

        virtual void register_methods_and_ctors()
        {
        }

        virtual void register_types()
        {
        }

        virtual void register_conversions()
        {
        }

        std::multimap<std::string, fwrap> _functions;
        std::map<const std::type_info *,
                 detail::object_method_store *,
                 detail::type_info_ptr_compare
                > _objects;
        std::map<std::string, const std::type_info *> _types;
        std::map<detail::type_info_conversion_store, val_convert_t> _ptr_conversions;
        std::map<detail::type_info_conversion_store, val_convert_t> _value_conversions;
        std::map<std::string, val> _globals;
        
        typedef std::multimap<std::string, fwrap>::const_iterator fwrap_it_t;
        
   
    private:
        bool _initialized;

        val val_cast_conversion(val& v, const std::type_info *desired_type,
                                bool can_use_temp) const;
       
        std::pair<fwrap, bool> find_best_match(std::pair<fwrap_it_t, fwrap_it_t>& candidate_range,
                                    fwrap_args::iterator args_begin, fwrap_args::iterator args_end,
                                    fwrap_args& best_match_args,
                                    std::vector<detail::conversion_rank>& best_match_rank);

        void throw_if_match_invalid(const std::string& name, std::pair<fwrap, bool>& best_match,
                                    fwrap_args& args);

        std::string type_name(const std::type_info *type) const;
      
        std::string format_fn_call_debug(const std::string& fn_name, fwrap_args& args) const;
      
        void remove_aliasing(val& v, fwrap& f, fwrap_args::iterator orig_arg_it,
                             fwrap_args::iterator actual_arg_it);
    
        execution_context(const execution_context& e);

        execution_context& operator=(const execution_context& rhs);
    };



    inline bool execution_context::point_to_same_obj(val& lhs, val& rhs) const
    {
        if(lhs.type() != rhs.type())
        {
            detail::type_info_conversion_store conv_id(&lhs.type(), &rhs.type());
            std::map<detail::type_info_conversion_store, val_convert_t>::const_iterator it;
            it = _ptr_conversions.find(conv_id);
            if(it != _ptr_conversions.end())
            {
                val conv_lhs(it->second(lhs)); // conv_lhs could be empty (cast failed)
                return conv_lhs.points_to_same_object_as(rhs);
            }
        }        
        return lhs.points_to_same_object_as(rhs);
    }

    template<typename DesiredT>
    inline DesiredT *execution_context::extended_val_cast_ptr(val& v) const
    {
        BOOST_STATIC_ASSERT(!boost::is_reference<DesiredT>::value);
        val converted_val(val_cast_conversion(v, &typeid(DesiredT), false));
        if(converted_val.empty())
        {
            throw bad_extended_val_cast(type_name(&v.type()), type_name(&typeid(DesiredT)));
        }
        return val_cast_ptr<DesiredT>(converted_val);
    }

    template<typename DesiredT>
    inline DesiredT execution_context::extended_val_cast_value(val& v) const
    {
        BOOST_STATIC_ASSERT(!boost::is_reference<DesiredT>::value);
        val converted_val(val_cast_conversion(v, &typeid(DesiredT), true));
        if(converted_val.empty())
        {
            throw bad_extended_val_cast(type_name(&v.type()), type_name(&typeid(DesiredT)));
        }
        return *val_cast_ptr<DesiredT>(converted_val);
    }

    inline val execution_context::val_cast_conversion_string(val& v,
                                          const std::string& desired_type, bool can_use_temp) const
    {
        std::map<std::string, const std::type_info *>::const_iterator type_it;
        type_it = _types.find(desired_type);
        if(type_it == _types.end())
        {
            throw unknown_type_exception(desired_type);
        }
        val converted_val(val_cast_conversion(v, type_it->second, can_use_temp));
        if(converted_val.empty())
        {
            throw bad_extended_val_cast(type_name(&v.type()), desired_type);
        }
        return converted_val;
    }


    inline val execution_context::call(fwrap& f, fwrap_args& args)
    {
        // We create a temporary map, so that we can get an iterator and use find_best_match.
        // This is not really ideal, but makes it consistent with call_method and call_function
        std::multimap<std::string, fwrap> temp;
        temp.insert(std::pair<std::string, fwrap>("temp", f));

        std::pair<fwrap_it_t, fwrap_it_t> candidate_range(temp.begin(), temp.end());
        fwrap_args best_match_args;
        std::vector<detail::conversion_rank> best_match_rank;
    
        std::pair<fwrap, bool> best_match(find_best_match(candidate_range,
                                                          args.begin(), args.end(),
                                                          best_match_args, best_match_rank));

        throw_if_match_invalid("unnamed_fwrap_object", best_match, args);
        val rv(best_match.first(best_match_args));
        remove_aliasing(rv, best_match.first, args.begin(), best_match_args.begin());
        
        return rv;

    }


    inline val execution_context::call_function(const std::string& fn_name, fwrap_args& args)
    {
        std::pair<fwrap_it_t, fwrap_it_t> candidate_range(_functions.equal_range(fn_name));
        fwrap_args best_match_args;
        std::vector<detail::conversion_rank> best_match_rank;
    
        std::pair<fwrap, bool> best_match(find_best_match(candidate_range,
                                                          args.begin(), args.end(),
                                                          best_match_args, best_match_rank));

        throw_if_match_invalid(fn_name, best_match, args);
        val rv(best_match.first(best_match_args));
        remove_aliasing(rv, best_match.first, args.begin(), best_match_args.begin());
        
        return rv;
    }


    inline val execution_context::call_method(const std::string& m_name, fwrap_args& args)
    {
        std::map<const std::type_info *, detail::object_method_store *,
                 detail::type_info_ptr_compare>::iterator type_it;
        type_it = _objects.find(&args.at(0).type());
        if(type_it == _objects.end())
        {
            throw unknown_type_exception(args[0].type().name());
        }

        std::pair<fwrap_it_t, fwrap_it_t> candidate_range_method(
                                                         type_it->second->get_methods(m_name));
        fwrap_args best_match_args_method;
        std::vector<detail::conversion_rank> best_match_rank_method;        
        std::pair<fwrap, bool> best_match_method(find_best_match(candidate_range_method,
                                              args.begin(), args.end(),
                                              best_match_args_method, best_match_rank_method));

        std::pair<fwrap_it_t, fwrap_it_t> candidate_range_static(
                                                  type_it->second->get_static_methods(m_name));
        fwrap_args best_match_args_static;
        std::vector<detail::conversion_rank> best_match_rank_static;
        std::pair<fwrap, bool> best_match_static(find_best_match(candidate_range_static,
                                              args.begin() + 1, args.end(),
                                              best_match_args_static, best_match_rank_static));

        std::pair<fwrap, bool> *best_match = &best_match_method;
        fwrap_args *best_match_args = &best_match_args_method;
        int is_static_offset = 0; // 0 or 1 only; can be used as offset to args.begin()
        if(!best_match_static.first.is_null())
        {
            if(best_match_method.first.is_null()
                    || detail::strictly_greater_or_equal_all(best_match_rank_static.begin(),
                                                          best_match_rank_static.end(),
                                                          best_match_rank_method.begin() + 1))
            {
                best_match = &best_match_static;
                best_match_args = &best_match_args_static;
                is_static_offset = 1;
            }
            else if(detail::strictly_greater_or_equal_all(best_match_rank_method.begin() + 1,
                                                          best_match_rank_method.end(),
                                                          best_match_rank_static.begin()))
            {
                // do nothing - best_match_method is best
            }
            else
            {
                best_match->second = true; // ambiguous
            }
        }

        throw_if_match_invalid(m_name, *best_match, args);
        val rv(best_match->first(*best_match_args));
        remove_aliasing(rv, best_match->first, args.begin() + is_static_offset,
                        best_match_args->begin());
        
        return rv;
    }

    inline val execution_context::call_function_or_method(const std::string& name,
                                                          fwrap_args& args)
    {
        std::pair<fwrap_it_t, fwrap_it_t> candidate_range_func(_functions.equal_range(name));
        fwrap_args best_match_args_func;
        std::vector<detail::conversion_rank> best_match_rank_func;
    
        std::pair<fwrap, bool> best_match_func(find_best_match(candidate_range_func,
                                                  args.begin(), args.end(),
                                                  best_match_args_func, best_match_rank_func));

        std::map<const std::type_info *, detail::object_method_store *,
                 detail::type_info_ptr_compare>::iterator type_it;
        type_it = _objects.find(&args.at(0).type());
        if(type_it == _objects.end())
        {
            // We could just keep going, only considering matching functions. Note sure yet
            // whether that's more useful than throwing.
            throw unknown_type_exception(args[0].type().name());
        }

        std::pair<fwrap_it_t, fwrap_it_t> candidate_range_method(
                                                           type_it->second->get_methods(name));
        fwrap_args best_match_args_method;
        std::vector<detail::conversion_rank> best_match_rank_method;        
        std::pair<fwrap, bool> best_match_method(find_best_match(candidate_range_method,
                                              args.begin(), args.end(),
                                              best_match_args_method, best_match_rank_method));

        std::pair<fwrap, bool> *best_match = &best_match_method;
        fwrap_args *best_match_args = &best_match_args_method;
        if(!best_match_func.first.is_null())
        {
            if(best_match_method.first.is_null()
                    || detail::strictly_greater_or_equal_all(best_match_rank_func.begin(),
                                                          best_match_rank_func.end(),
                                                          best_match_rank_method.begin()))
            {
                best_match = &best_match_func;
                best_match_args = &best_match_args_func;
            }
            else if(detail::strictly_greater_or_equal_all(best_match_rank_method.begin(),
                                                          best_match_rank_method.end(),
                                                          best_match_rank_func.begin()))
            {
                // do nothing - best_match_method is best
            }
            else
            {
                best_match->second = true; // ambiguous
            }
        }

        throw_if_match_invalid(name, *best_match, args);
        val rv(best_match->first(*best_match_args));
        remove_aliasing(rv, best_match->first, args.begin(), best_match_args->begin());
        
        return rv;
    }



    val& execution_context::get_global(const std::string& name)
    {
        std::map<std::string, val>::iterator it;
        it = _globals.find(name);
        if(it == _globals.end())
        {
            throw undefined_global_exception(name);
        }
        return it->second;
    }

    const val& execution_context::get_global(const std::string& name) const
    {
        std::map<std::string, val>::const_iterator it;
        it = _globals.find(name);
        if(it == _globals.end())
        {
            throw undefined_global_exception(name);
        }
        return it->second;
    }

    void execution_context::add_global(const std::string& name, const val& v)
    {
        std::pair<std::map<std::string, val>::iterator, bool> rv(_globals.insert(
                                                            std::pair<std::string, val>(name, v)));
        if(!rv.second)
        {
            throw redefined_global_exception(name);
        }
    }

    val& execution_context::operator[](const std::string& name)
    {
        return _globals[name];
    }

    void execution_context::clear_globals()
    {
        _globals.clear();
    }

    inline execution_context::~execution_context()
    {
        std::map<const std::type_info *, detail::object_method_store *,
                 detail::type_info_ptr_compare>::iterator it;
        for(it = _objects.begin(); it != _objects.end(); ++it)
        {
            delete it->second;   
        }
    }



    inline val execution_context::val_cast_conversion(val& v, const std::type_info *desired_type,
                                                      bool can_use_temp) const
    {
        detail::type_info_conversion_store conv_id(&v.type(), desired_type);
        std::map<detail::type_info_conversion_store, val_convert_t>::const_iterator it;
        it = _ptr_conversions.find(conv_id);
        if(it == _ptr_conversions.end())
        {
            if(!can_use_temp)
            {
                return val();
            }

            it = _value_conversions.find(conv_id);
            if(it == _value_conversions.end())
            {
                return val();
            }
        }
        return it->second(v);
    }


    inline std::pair<fwrap, bool> execution_context::find_best_match(
                                std::pair<fwrap_it_t, fwrap_it_t>& candidate_range,
                                fwrap_args::iterator args_begin, fwrap_args::iterator args_end,
                                fwrap_args& best_match_args,
                                std::vector<detail::conversion_rank>& best_match_rank)
    {
        fwrap best_match; // return value
        bool best_match_ambiguous = false;

        for(fwrap_it_t it = candidate_range.first; it != candidate_range.second; ++it)
        {
            const fwrap& curr_match = it->second;
            std::vector<detail::conversion_rank> curr_match_rank;
            fwrap_args curr_match_args;

            if(static_cast<int>(curr_match.arity()) != std::distance(args_begin, args_end))
            {
                continue;
            }

            std::vector<arg_info> arg_meta;
            curr_match.get_arg_info(arg_meta);
            std::vector<arg_info>::const_iterator arg_meta_it = arg_meta.begin();
            fwrap_args::iterator args_it = args_begin;
            for( ; args_it != args_end; args_it++, arg_meta_it++)
            {
                if(args_it->empty())
                {
                    if(!arg_meta_it->is_pointer())
                    {
                        goto try_next_fn;
                    }
                    curr_match_rank.push_back(detail::CONVERSION_OTHER_CONVERSION);
                    curr_match_args.push_back(*args_it);
                }
                else
                {
                    // check constness matches
                    if(args_it->is_const() && !arg_meta_it->is_const())
                    {
                        goto try_next_fn;
                    }
                    if(args_it->type() == arg_meta_it->type())
                    {
                        if(args_it->is_const() == arg_meta_it->is_const()
                            || (!arg_meta_it->is_pointer() && !arg_meta_it->is_reference()))
                        {
                            curr_match_rank.push_back(detail::CONVERSION_EXACT_MATCH);
                        }
                        else
                        {
                            curr_match_rank.push_back(detail::CONVERSION_QUALIFICATION);
                        }
                        curr_match_args.push_back(*args_it);
                    }
                    else
                    {
                        bool can_use_temp = !arg_meta_it->is_pointer()
                                  && (!arg_meta_it->is_reference() || arg_meta_it->is_const());
                        val converted_val(val_cast_conversion(*args_it, &arg_meta_it->type(),
                                                              can_use_temp));
                        if(converted_val.empty())
                        {
                            goto try_next_fn;
                        }
                        curr_match_rank.push_back(detail::CONVERSION_OTHER_CONVERSION);
                        curr_match_args.push_back(converted_val);
                    }
                }
            }
            if(best_match.is_null()
                            || detail::strictly_greater_or_equal_all(curr_match_rank.begin(),
                                                                     curr_match_rank.end(),
                                                                     best_match_rank.begin()))
            {
                best_match = curr_match;
                best_match_args = curr_match_args;
                best_match_rank = curr_match_rank;
                best_match_ambiguous = false;
            }
            else if(detail::strictly_greater_or_equal_all(best_match_rank.begin(),
                                                          best_match_rank.end(),
                                                          curr_match_rank.begin()))
            {
                // nothing to do; best_match is better than curr_match
            }
            else
            {
                // best_match is just as good as curr_match (according to overload rules)
                best_match_ambiguous = true;
            }

            try_next_fn:
            ;
        }
        return std::pair<fwrap, bool>(best_match, best_match_ambiguous);
    }

    inline void execution_context::throw_if_match_invalid(const std::string& name,
                                                          std::pair<fwrap, bool>& best_match,
                                                          fwrap_args& args)
    {
        if(best_match.first.is_null())
        {
            throw no_matching_function_exception(format_fn_call_debug(name, args));
        }
        if(best_match.second)
        {
            throw ambiguous_overload_exception(format_fn_call_debug(name, args));
        }
    }

    inline std::string execution_context::type_name(const std::type_info *type) const
    {
        std::map<const std::type_info *, detail::object_method_store *,
                 detail::type_info_ptr_compare>::const_iterator type_it;
        type_it = _objects.find(type);
        std::string rv;
        if(type_it == _objects.end())
        {
            rv = "[unregistered type] ";
            rv += type->name();
        }
        else
        {
            rv = type_it->second->get_obj_name();
        }
        return rv;
    }


    inline std::string execution_context::format_fn_call_debug(const std::string& fn_name,
                                                               fwrap_args& args) const
    {
        std::string rv(fn_name);
        rv += "(";
        for(fwrap_args::const_iterator arg_it = args.begin(); arg_it != args.end(); ++arg_it)
        {
            if(arg_it != args.begin())
            {
                rv += ", ";
            }

            rv += type_name(&arg_it->type());
            if(arg_it->is_const())
            {
                rv += " const";
            }
        }
        rv += ")";
        return rv;
    }

    inline void execution_context::remove_aliasing(val& v, fwrap& f,
                                                   fwrap_args::iterator orig_arg_it,
                                                   fwrap_args::iterator actual_arg_it)
    {
        arg_info rv_arg_meta(f.get_rv_info());
        if(!rv_arg_meta.is_pointer() && !rv_arg_meta.is_reference())
        {
            return;
        }
        std::vector<arg_info> arg_meta;
        f.get_arg_info(arg_meta);
        std::vector<arg_info>::const_iterator arg_meta_it = arg_meta.begin();
        for( ; arg_meta_it != arg_meta.end(); arg_meta_it++, orig_arg_it++, actual_arg_it++)
        {
            if(arg_meta_it->is_reference() || arg_meta_it->is_pointer())
            {
                if(point_to_same_obj(v, *orig_arg_it))
                {
                    v = *orig_arg_it;
                    break;
                }

                // const reference parameters require special treatment, since one can
                // bind a temporary to these (such temporary would be stored in actual_args)
                if(arg_meta_it->is_const() && arg_meta_it->is_reference())
                {
                    if(point_to_same_obj(v, *actual_arg_it))
                    {
                        v = *actual_arg_it;
                        break;
                    }
                }
            }
        }
    }


} //namespace eval




#endif

---