libs/python/src/functions.cpp0100644000076400010400000001365607353146642013575 0ustar // (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // The author gratefully acknowleges the support of Dragon Systems, Inc., in // producing this work. // // Revision History: // Mar 01 01 Use PyObject_INIT() instead of trying to hand-initialize (David Abrahams) #include #include #include #include #include #include namespace boost { namespace python { namespace detail { struct function::type_object : singleton > > > { type_object() : singleton_base(&PyType_Type) {} }; PyObject* function::getattr(const char* name) const { if (!strcmp(name, "__doc__")) return ref(m_doc_string).release(); else return 0; } void function::add_to_namespace(reference new_function, const char* name, PyObject* dict) { dictionary d(ref(dict, ref::increment_count)); string key(name); ref existing_object = d.get_item(key.reference()); if (existing_object.get() == 0) { d[key] = ref(new_function.get(), ref::increment_count); } else { if (existing_object->ob_type == type_object::instance()) { function* f = static_cast(existing_object.get()); while (f->m_overloads.get() != 0) f = f->m_overloads.get(); f->m_overloads = new_function; } else { PyErr_SetObject(PyExc_RuntimeError, (string("Attempt to overload ") + name + " failed. The existing attribute has type " + existing_object->ob_type->tp_name).get()); throw error_already_set(); } } } function::function() : python_object(type_object::instance()) { } function::function(ref doc_string) : python_object(type_object::instance()) , m_doc_string(doc_string) { if (doc_string.get()) { // this is a cheesy hack which will generate an exception if doc_string // is not actually a string. string(doc_string); } } PyObject* function::call(PyObject* args, PyObject* keywords) const { for (const function* f = this; f != 0; f = f->m_overloads.get()) { PyErr_Clear(); try { PyObject* const result = f->do_call(args, keywords); if (result != 0) return result; } catch(const argument_error&) { } } if (m_overloads.get() == 0) return 0; PyErr_Clear(); string message("No overloaded functions match ("); tuple arguments(ref(args, ref::increment_count)); for (std::size_t i = 0; i < arguments.size(); ++i) { if (i != 0) message += ", "; message += arguments[i]->ob_type->tp_name; } message += "). Candidates are:\n"; for (const function* f1 = this; f1 != 0; f1 = f1->m_overloads.get()) { if (f1 != this) message += "\n"; message += f1->description(); } PyErr_SetObject(PyExc_TypeError, message.get()); return 0; } // The instance class whose obj represents the type of bound_function // objects in Python. bound_functions must be GetAttrable so the __doc__ // attribute of built-in Python functions can be accessed when bound. struct bound_function::type_object : singleton > > > { type_object() : singleton_base(&PyType_Type) {} private: // type_object hook override void dealloc(bound_function*) const; }; bound_function* bound_function::create(const ref& target, const ref& fn) { bound_function* const result = free_list; if (result == 0) return new bound_function(target, fn); free_list = result->m_free_list_link; result->m_target = target; result->m_unbound_function = fn; PyObject* self = result; PyObject_INIT(self, type_object::instance()); return result; } bound_function::bound_function(const ref& target, const ref& fn) : python_object(type_object::instance()), m_target(target), m_unbound_function(fn), m_free_list_link(0) { } PyObject* bound_function::call(PyObject* args, PyObject* keywords) const { // Build a new tuple which prepends the target to the arguments tuple tail_arguments(ref(args, ref::increment_count)); ref all_arguments(PyTuple_New(tail_arguments.size() + 1)); PyTuple_SET_ITEM(all_arguments.get(), 0, m_target.get()); Py_INCREF(m_target.get()); for (std::size_t i = 0; i < tail_arguments.size(); ++i) { PyTuple_SET_ITEM(all_arguments.get(), i + 1, tail_arguments[i].get()); Py_INCREF(tail_arguments[i].get()); } return PyEval_CallObjectWithKeywords(m_unbound_function.get(), all_arguments.get(), keywords); } PyObject* bound_function::getattr(const char* name) const { return PyObject_GetAttrString(m_unbound_function.get(), const_cast(name)); } void bound_function::type_object::dealloc(bound_function* obj) const { obj->m_free_list_link = free_list; free_list = obj; obj->m_target.reset(); obj->m_unbound_function.reset(); } bound_function* bound_function::free_list; }}} // namespace boost::python::detail boost/python/detail/functions.hpp0100644000076400010400000002575507353147430014451 0ustar // (C) Copyright David Abrahams 2000. Permission to copy, use, modify, sell and // distribute this software is granted provided this copyright notice appears // in all copies. This software is provided "as is" without express or implied // warranty, and with no claim as to its suitability for any purpose. // // The author gratefully acknowleges the support of Dragon Systems, Inc., in // producing this work. #ifndef FUNCTIONS_DWA051400_H_ # define FUNCTIONS_DWA051400_H_ # include # include # include # include # include # include # include # include # include # include namespace boost { namespace python { namespace detail { // forward declaration class extension_instance; // function -- // the common base class for all overloadable function and method objects // supplied by the library. class function : public python_object { public: function(ref doc_string = ref()); // function objects are reasonably rare, so we guess we can afford a virtual table. // This cuts down on the number of distinct type objects which need to be defined. virtual ~function() {} PyObject* call(PyObject* args, PyObject* keywords) const; static void add_to_namespace(reference f, const char* name, PyObject* dict); private: virtual PyObject* do_call(PyObject* args, PyObject* keywords) const = 0; virtual const char* description() const = 0; virtual PyObject* getattr(PyObject* name) const = 0; private: struct type_object; private: reference m_overloads; ref m_doc_string; }; // wrapped_function_pointer<> -- // A single function or member function pointer wrapped and presented to // Python as a callable object. // // Template parameters: // R - the return type of the function pointer // F - the complete type of the wrapped function pointer template struct wrapped_function_pointer : function { typedef F ptr_fun; // pointer-to--function or pointer-to-member-function wrapped_function_pointer(ptr_fun pf, ref doc_string = ref()) private: PyObject* do_call(PyObject* args, PyObject* keywords) const const char* description() const private: const ptr_fun m_pf; }; // raw_arguments_function // A function that passes the Python argument tuple and keyword dictionary // verbatim to C++ (useful for customized argument parsing and variable // argument lists) template struct raw_arguments_function : function { typedef Ret (*ptr_fun)(Args, Keywords); raw_arguments_function(ptr_fun pf, ref doc_string = ref()) : function(doc_string) , m_pf(pf) {} private: PyObject* do_call(PyObject* args, PyObject* keywords) const { ref dict(keywords ? ref(keywords, ref::increment_count) : ref(PyDict_New())); return to_python( (*m_pf)(from_python(args, boost::python::type()), from_python(dict.get(), boost::python::type()))); } const char* description() const { return typeid(ptr_fun).name(); } private: const ptr_fun m_pf; }; // virtual_function<> -- // A virtual function with a default implementation wrapped and presented // to Python as a callable object. // // Template parameters: // T - the type of the target class // R - the return type of the function pointer // V - the virtual function pointer being wrapped // (should be of the form R(T::*)(), or R (*)(T, )) // D - a function which takes a T&, const T&, T*, or const T* first // parameter and calls T::f on it /non-virtually/, where V // approximates &T::f. template class virtual_function : public function { public: virtual_function(V virtual_function_ptr, D default_implementation, ref doc_string = ref()) : function(doc_string) , m_virtual_function_ptr(virtual_function_ptr) , m_default_implementation(default_implementation) {} private: PyObject* do_call(PyObject* args, PyObject* keywords) const; const char* description() const { return typeid(V).name(); } private: const V m_virtual_function_ptr; const D m_default_implementation; }; // A helper function for new_member_function(), below. Implements the core // functionality once the return type has already been deduced. R is expected to // be type, where X is the actual return type of pmf. template function* new_wrapped_function_aux(R, F pmf, ref doc_string) { // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes. typedef typename R::type return_type; return new wrapped_function_pointer(pmf, doc_string); } // Create and return a new member function object wrapping the given // pointer-to-member function template inline function* new_wrapped_function(F pmf, ref doc_string = ref()) { // Deduce the return type and pass it off to the helper function above return new_wrapped_function_aux(return_value(pmf), pmf, doc_string); } template function* new_raw_arguments_function(R (*pmf)(Args, keywords), ref doc_string = ref()) { return new raw_arguments_function(pmf, doc_string); } // A helper function for new_virtual_function(), below. Implements the core // functionality once the return type has already been deduced. R is expected to // be type, where X is the actual return type of V. template inline function* new_virtual_function_aux( type, R, V virtual_function_ptr, D default_implementation, ref doc_string ) { // We can't just use "typename R::Type" below because MSVC (incorrectly) pukes. typedef typename R::type return_type; return new virtual_function( virtual_function_ptr, default_implementation, doc_string); } // Create and return a new virtual_function object wrapping the given // virtual_function_ptr and default_implementation template inline function* new_virtual_function( type, V virtual_function_ptr, D default_implementation, ref doc_string = ref() ) { // Deduce the return type and pass it off to the helper function above return new_virtual_function_aux( type(), return_value(virtual_function_ptr), virtual_function_ptr, default_implementation, doc_string); } // A function with a bundled "bound target" object. This is what is produced by // the expression a.b where a is an instance or extension_instance object and b // is a callable object not found in the obj namespace but on its class or // a base class. class bound_function : public python_object { public: static bound_function* create(const ref& target, const ref& fn); bound_function(const ref& target, const ref& fn); PyObject* call(PyObject*args, PyObject* keywords) const; PyObject* getattr(const char* name) const; private: struct type_object; friend struct type_object; ref m_target; ref m_unbound_function; private: // data members for allocation/deallocation optimization bound_function* m_free_list_link; static bound_function* free_list; }; // Special functions designed to access data members of a wrapped C++ object. template class getter_function : public function { public: typedef MemberType ClassType::* pointer_to_member; getter_function(pointer_to_member pm, ref doc_string = ref()) : function(doc_string), m_pm(pm) {} private: PyObject* do_call(PyObject* args, PyObject* keywords) const; const char* description() const { return typeid(MemberType (*)(const ClassType&)).name(); } private: pointer_to_member m_pm; }; template class setter_function : public function { public: typedef MemberType ClassType::* pointer_to_member; setter_function(pointer_to_member pm, ref doc_string = ref()) : function(doc_string), m_pm(pm) {} private: PyObject* do_call(PyObject* args, PyObject* keywords) const; const char* description() const { return typeid(void (*)(const ClassType&, const MemberType&)).name(); } private: pointer_to_member m_pm; }; template PyObject* getter_function::do_call( PyObject* args, PyObject* /* keywords */) const { PyObject* self; if (!PyArg_ParseTuple(args, const_cast("O"), &self)) return 0; return to_python( from_python(self, type())->*m_pm); } template PyObject* setter_function::do_call( PyObject* args, PyObject* /* keywords */) const { PyObject* self; PyObject* value; if (!PyArg_ParseTuple(args, const_cast("OO"), &self, &value)) return 0; typedef typename boost::call_traits::const_reference extract_type; from_python(self, type())->*m_pm = from_python(value, type()); return none(); } template PyObject* virtual_function::do_call(PyObject* args, PyObject* keywords) const { // If the target object is held by pointer, we must call through the virtual // function pointer to the most-derived override. PyObject* target = PyTuple_GetItem(args, 0); if (target != 0) { extension_instance* self = get_extension_instance(target); if (self->wrapped_objects().size() == 1 && !self->wrapped_objects()[0]->held_by_value()) { return caller::call(m_virtual_function_ptr, args, keywords); } } return caller::call(m_default_implementation, args, keywords); } // // implementation details // template wrapped_function_pointer::wrapped_function_pointer(ptr_fun pf, ref doc_string) : function(doc_string) , m_pf(pf) {} template PyObject* wrapped_function_pointer::do_call(PyObject* args, PyObject* keywords) const { return caller::call(m_pf, args, keywords); } template const char* wrapped_function_pointer::description() const { return typeid(F).name(); } }}} // namespace boost::python::detail #endif // FUNCTIONS_DWA051400_H_