From 61ba4cd1ce3d73d661b4b1c6c2fd454e1f3540ef Mon Sep 17 00:00:00 2001 From: David Hawkes Date: Wed, 17 Jul 2002 06:51:08 +0000 Subject: [PATCH] Sub-module / sub-class and API changes [SVN r14488] --- Jamfile | 1 + include/boost/python/class.hpp | 38 +- include/boost/python/detail/module_base.hpp | 16 + include/boost/python/detail/module_info.hpp | 51 + include/boost/python/detail/module_init.hpp | 18 +- include/boost/python/module.hpp | 27 +- include/boost/python/object/class.hpp | 5 + include/boost/python/object_core.hpp | 1 - include/boost/python/py_interface.hpp | 700 ++++++++++++ src/gen_py_api.py | 776 +++++++++++++ src/module.cpp | 139 ++- src/object/class.cpp | 117 +- src/py_interface.cpp | 1103 +++++++++++++++++++ test/Jamfile | 1 + test/submod_subclass_api.cpp | 231 ++++ 15 files changed, 3204 insertions(+), 20 deletions(-) create mode 100644 include/boost/python/detail/module_info.hpp create mode 100644 include/boost/python/py_interface.hpp create mode 100644 src/gen_py_api.py create mode 100644 src/py_interface.cpp create mode 100644 test/submod_subclass_api.cpp diff --git a/Jamfile b/Jamfile index 192982f6..503db998 100644 --- a/Jamfile +++ b/Jamfile @@ -23,6 +23,7 @@ dll bpl src/object/function.cpp src/object/inheritance.cpp src/object/life_support.cpp + src/py_interface.cpp src/errors.cpp src/module.cpp src/objects2.cpp diff --git a/include/boost/python/class.hpp b/include/boost/python/class.hpp index 861d8e72..d2a4a2f0 100644 --- a/include/boost/python/class.hpp +++ b/include/boost/python/class.hpp @@ -14,6 +14,7 @@ # include # include # include +# include # include # include # include @@ -86,12 +87,12 @@ class class_ : public objects::class_base public: // Automatically derive the class name - only works on some // compilers because type_info::name is sometimes mangled (gcc) - class_(); + class_(base const& parent_class = empty_class_base()); // Construct with the class name. [ Would have used a default // argument but gcc-2.95.2 choked on typeid(T).name() as a default // parameter value] - class_(char const* name); + class_(char const* name, base const& parent_class = empty_class_base()); // Wrap a member function or a non-member function which can take @@ -195,6 +196,22 @@ class class_ : public objects::class_base self& setattr(char const* name, handle<> const&); + // add to module + self& add(module &m) + { + // redundant + // m.add(*this); + return *this; + } + + // add to current module + self& add() + { + // redundant + // boost::python::add(*this); + return *this; + } + private: // types typedef objects::class_id class_id; @@ -231,7 +248,7 @@ class class_ : public objects::class_base // implementations // template -inline class_::class_() +inline class_::class_(base const& parent_class) : base(typeid(T).name(), id_vector::size, id_vector().ids) { // register converters @@ -241,10 +258,16 @@ inline class_::class_() mpl::bool_t() , objects::select_holder((held_type*)0).get() , this->object()); + + // get the context to add the class to + handle<> parent(parent_class.object() ? handle<>(parent_class.object()) : + base::get_class_context_object(typeid(T).name(), object())); + // add the class to the current module + boost::python::detail::module_base::add(object(), parent); } template -inline class_::class_(char const* name) +inline class_::class_(char const* name, base const& parent_class) : base(name, id_vector::size, id_vector().ids) { // register converters @@ -254,8 +277,13 @@ inline class_::class_(char const* name) mpl::bool_t() , objects::select_holder((held_type*)0).get() , this->object()); -} + // get the context to add the class to + handle<> parent(parent_class.object() ? handle<>(parent_class.object()) : + base::get_class_context_object(name, object())); + // add the class to the current module + boost::python::detail::module_base::add(object(), parent); +} template inline class_& class_::add_property(char const* name, handle<> const& fget) diff --git a/include/boost/python/detail/module_base.hpp b/include/boost/python/detail/module_base.hpp index aaa6a135..71044c96 100644 --- a/include/boost/python/detail/module_base.hpp +++ b/include/boost/python/detail/module_base.hpp @@ -10,6 +10,8 @@ namespace boost { namespace python { namespace detail { +class module_info; + class BOOST_PYTHON_DECL module_base { public: @@ -21,14 +23,22 @@ class BOOST_PYTHON_DECL module_base void setattr(const char* name, PyObject*); void setattr(const char* name, handle<> const&); void add(type_handle const&); // just use the type's name + static module_info* get_module_info(); + static void set_module_info(module_info& mi); + static handle<> get_prior_module(); + static void set_prior_module(handle<> const& m); + static void add(type_handle const& class_obj, handle<> const& context); // Return a reference to the Python module object being built inline handle<> object() const; protected: + module_base(handle<> const &m) : m_module(m) {} void add_class(type_handle const& class_obj); + void add_class(type_handle const& class_obj, handle<> const& context); private: + static module_info*& get_module_info_ref(); handle<> m_module; static PyMethodDef initial_methods[1]; }; @@ -41,6 +51,12 @@ inline handle<> module_base::object() const return m_module; } +inline void module_base::add(type_handle const& class_obj, handle<> const& context) +{ + module_base mb(get_prior_module()); + mb.add_class(class_obj, context); +} + }}} // namespace boost::python::detail #endif // MODULE_BASE_DWA2002227_HPP diff --git a/include/boost/python/detail/module_info.hpp b/include/boost/python/detail/module_info.hpp new file mode 100644 index 00000000..ba3f91cc --- /dev/null +++ b/include/boost/python/detail/module_info.hpp @@ -0,0 +1,51 @@ +// Copyright David Hawkes 2002. +// Permission is hereby granted to copy, use and modify this software +// for any purpose, including commercial distribution, provided this +// copyright notice is not removed. No warranty WHATSOEVER is provided with this +// software. Any user(s) accepts this software "as is" and as such they will not +// bind the author(s) to any claim of suitabilty for any purpose. + +#ifndef MODULE_INFO +# define MODULE_INFO + +#include + +namespace boost { namespace python { namespace detail { + +class module_info +{ +public: + module_info(const char *name) + { + m_module_name = name; + } + void set_module(object const& m) + { + if(!m_primary_module) + m_primary_module = m; + } + object const& get_module() const + { + return m_primary_module; + } + void set_prior_module(object const& m) + { + m_prior_module = m; + } + object const& get_prior_module() const + { + return m_prior_module; + } + const char* get_module_name() const + { + return m_module_name; + } +private: + object m_primary_module; + object m_prior_module; + const char* m_module_name; +}; + +}}} + +#endif // MODULE_INFO diff --git a/include/boost/python/detail/module_init.hpp b/include/boost/python/detail/module_init.hpp index 5b5ce9f5..79a55119 100644 --- a/include/boost/python/detail/module_init.hpp +++ b/include/boost/python/detail/module_init.hpp @@ -8,13 +8,23 @@ # ifndef BOOST_PYTHON_MODULE_INIT +# define PRE_INIT_FUNC(name) \ +void init_module_base_##name() \ +{ \ + boost::python::detail::module_info mi(#name); \ + boost::python::detail::module_base::set_module_info(mi); \ + boost::python::module(); \ + init_module_##name(); \ +} + # if defined(_WIN32) || defined(__CYGWIN__) # define BOOST_PYTHON_MODULE_INIT(name) \ void init_module_##name(); \ +PRE_INIT_FUNC(name) \ extern "C" __declspec(dllexport) void init##name() \ { \ - boost::python::handle_exception(&init_module_##name); \ + boost::python::handle_exception(&init_module_base_##name); \ } \ void init_module_##name() @@ -22,13 +32,14 @@ void init_module_##name() # include # define BOOST_PYTHON_MODULE_INIT(name) \ +PRE_INIT_FUNC(name) \ void init_module_##name(); \ extern "C" \ { \ extern PyObject* _PyImport_LoadDynamicModule(char*, char*, FILE *); \ void init##name() \ { \ - boost::python::detail::aix_init_module(_PyImport_LoadDynamicModule, &init_module_##name); \ + boost::python::detail::aix_init_module(_PyImport_LoadDynamicModule, &init_module_base_##name); \ } \ } \ void init_module_##name() @@ -36,10 +47,11 @@ void init_module_##name() # else # define BOOST_PYTHON_MODULE_INIT(name) \ +PRE_INIT_FUNC(name) \ void init_module_##name(); \ extern "C" void init##name() \ { \ - boost::python::handle_exception(&init_module_##name); \ + boost::python::handle_exception(&init_module_base_##name); \ } \ void init_module_##name() diff --git a/include/boost/python/module.hpp b/include/boost/python/module.hpp index 8ee63485..d32e0935 100644 --- a/include/boost/python/module.hpp +++ b/include/boost/python/module.hpp @@ -13,6 +13,7 @@ # include # include # include +# include namespace boost { namespace python { @@ -21,7 +22,7 @@ class module : public detail::module_base public: typedef detail::module_base base; - module(const char* name) + module(const char* name = "") : base(name) {} // Add elements to the module @@ -33,7 +34,8 @@ class module : public detail::module_base template module& add(class_ const& c) { - this->add_class(c.object()); + // redundant + // this->add_class(c.object()); return *this; } @@ -51,6 +53,14 @@ class module : public detail::module_base this->setattr(name, boost::python::make_function(fn, handler)); return *this; } + + static module get_prior_module() + { + return module(module_base::get_prior_module()); + } + + private: + module(handle<> const& m) : base(m) {} }; // @@ -80,6 +90,19 @@ inline module& module::add(PyTypeObject* x) return *this; } +template +inline void def(char const* name, Fn fn) +{ + module::get_prior_module().def(name, fn); +} + + +template +inline void def(char const* name, Fn fn, ResultHandler handler) +{ + module::get_prior_module().def(name, fn, handler); +} + }} // namespace boost::python #endif // MODULE_DWA20011221_HPP diff --git a/include/boost/python/object/class.hpp b/include/boost/python/object/class.hpp index 8cf29b23..8e4cf586 100644 --- a/include/boost/python/object/class.hpp +++ b/include/boost/python/object/class.hpp @@ -39,7 +39,12 @@ struct BOOST_PYTHON_DECL class_base : private noncopyable void add_property(char const* name, handle<> const& fget); void add_property(char const* name, handle<> const& fget, handle<> const& fset); void setattr(char const* name, handle<> const&); + static handle<> get_class_context_object(const char* name, type_handle const& class_obj); + protected: + static class_base const& empty_class_base(); private: + // construct an empty base class + class_base(); type_handle m_object; }; diff --git a/include/boost/python/object_core.hpp b/include/boost/python/object_core.hpp index 965e966e..4ac0dcea 100755 --- a/include/boost/python/object_core.hpp +++ b/include/boost/python/object_core.hpp @@ -325,7 +325,6 @@ inline object::object(detail::borrowed_reference p) : object_base(python::incref((PyObject*)p)) {} - inline object::object(detail::new_reference p) : object_base(expect_non_null((PyObject*)p)) {} diff --git a/include/boost/python/py_interface.hpp b/include/boost/python/py_interface.hpp new file mode 100644 index 00000000..c1416d5c --- /dev/null +++ b/include/boost/python/py_interface.hpp @@ -0,0 +1,700 @@ +// Automatically generated from py_api_gen.py +#ifndef PY_INTERFACE_HPP +#define PY_INTERFACE_HPP + +#include +#include + +namespace boost { namespace python { namespace api { + +enum call_dict_usage { use_new_dict, use_local_dict, use_global_dict }; + +namespace api_detail { + +BOOST_PYTHON_DECL object get_func(const char* name); +BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...); +BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...); + +template +struct get_arg +{ + get_arg(A const &a) : h(a) {} + object h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +template<> +struct get_arg +{ + get_arg(object const &a) : h(a) {} + object const &h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +template<> +struct get_arg +{ + get_arg(PyObject* a) : h((python::detail::borrowed_reference)a) {} + object h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +} + +BOOST_PYTHON_DECL object locals(); + + +template +object abs(A0 const& a0) +{ + return api_detail::get_func("abs")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object abs(object const& a0); +BOOST_PYTHON_DECL object abs(short a0); +BOOST_PYTHON_DECL object abs(int a0); +BOOST_PYTHON_DECL object abs(long a0); +BOOST_PYTHON_DECL object abs(double const & a0); +BOOST_PYTHON_DECL object apply(object const& a0, object const& a1); +BOOST_PYTHON_DECL object apply(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL bool callable(object const& a0); +template +object chr(A0 const& a0) +{ + return api_detail::get_func("chr")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object chr(object const& a0); +BOOST_PYTHON_DECL object chr(short a0); +BOOST_PYTHON_DECL object chr(int a0); +BOOST_PYTHON_DECL object chr(long a0); +template +int cmp(A0 const& a0, A1 const& a1) +{ + int rslt; + int r = ::PyObject_Cmp(api_detail::get_arg(a0), api_detail::get_arg(a1), &rslt); + if(r == -1) + throw_error_already_set(); + return rslt; +} +BOOST_PYTHON_DECL int cmp(object const& a0, object const& a1); +BOOST_PYTHON_DECL object coerce(object const& a0, object const& a1); +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2); +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3); +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3, int a4); +template +object complex(A0 const& a0) +{ + return api_detail::get_func("complex")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object complex(object const& a0); +BOOST_PYTHON_DECL object complex(double const& a0); +template +object complex(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("complex")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object complex(object const& a0, object const& a1); +BOOST_PYTHON_DECL object complex(double const& a0, double const& a1); +BOOST_PYTHON_DECL object dict(); +BOOST_PYTHON_DECL object dict(object const& a0); +BOOST_PYTHON_DECL object dir(); +BOOST_PYTHON_DECL object dir(object const& a0); +template +object divmod(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("divmod")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object divmod(object const& a0, object const& a1); +BOOST_PYTHON_DECL object divmod(int a0, int a1); +BOOST_PYTHON_DECL object divmod(long a0, long a1); +BOOST_PYTHON_DECL object divmod(double const& a0, double const& a1); +BOOST_PYTHON_DECL object eval(const char* a0); +BOOST_PYTHON_DECL object eval(const char* a0, object const& a2); +BOOST_PYTHON_DECL object eval(const char* a0, object const& a2, object const& a3); +BOOST_PYTHON_DECL object exec(const char* a0); +BOOST_PYTHON_DECL object exec(const char* a0, object const& a2); +BOOST_PYTHON_DECL object exec(const char* a0, object const& a2, object const& a3); +BOOST_PYTHON_DECL object execfile(object const& a0); +BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1); +BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object file(object const& a0); +BOOST_PYTHON_DECL object file(const char* a0); +BOOST_PYTHON_DECL object file(object const& a0, object const& a1); +BOOST_PYTHON_DECL object file(const char* a0, const char* a1); +BOOST_PYTHON_DECL object file(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object file(const char* a0, const char* a1, int a2); +BOOST_PYTHON_DECL object filter(object const& a0, object const& a1); +BOOST_PYTHON_DECL object float_(object const& a0); +BOOST_PYTHON_DECL object float_(const char* a0); +BOOST_PYTHON_DECL object float_(double const& a0); +BOOST_PYTHON_DECL object getattr(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object getattr(object const& a0, const char * a1, object const& a2); +BOOST_PYTHON_DECL object globals(); +BOOST_PYTHON_DECL bool hasattr(object const& a0, object const& a1); +BOOST_PYTHON_DECL bool hasattr(object const& a0, const char* a1); +BOOST_PYTHON_DECL long hash(object const& a0); +template +object hex(A0 const& a0) +{ + return api_detail::get_func("hex")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object hex(object const& a0); +BOOST_PYTHON_DECL object hex(char a0); +BOOST_PYTHON_DECL object hex(short a0); +BOOST_PYTHON_DECL object hex(int a0); +BOOST_PYTHON_DECL object hex(long a0); +BOOST_PYTHON_DECL long id(object const& a0); +BOOST_PYTHON_DECL object input(); +BOOST_PYTHON_DECL object input(object const& a0); +BOOST_PYTHON_DECL object input(const char* a0); +BOOST_PYTHON_DECL object int_(object const& a0); +BOOST_PYTHON_DECL object int_(long a0); +BOOST_PYTHON_DECL object int_(const char* a0); +BOOST_PYTHON_DECL object intern(object const& a0); +BOOST_PYTHON_DECL object intern(const char* a0); +BOOST_PYTHON_DECL bool isinstance(object const& a0, object const& a1); +BOOST_PYTHON_DECL bool issubclass(object const& a0, object const& a1); +BOOST_PYTHON_DECL object iter(object const& a0); +BOOST_PYTHON_DECL object iter(object const& a0, object const& a1); +BOOST_PYTHON_DECL long len(object const& a0); +BOOST_PYTHON_DECL object list(); +BOOST_PYTHON_DECL object list(object const& a0); +BOOST_PYTHON_DECL object long_(object const& a0); +BOOST_PYTHON_DECL object long_(long a0); +BOOST_PYTHON_DECL object long_(const char* a0); +BOOST_PYTHON_DECL object map(object const& a0); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +template +object max(A0 const& a0) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0)); +} +template +object max(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7), api_detail::get_arg(a8)); +} +template +object max(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::get_func("max")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7), api_detail::get_arg(a8), api_detail::get_arg(a9)); +} +BOOST_PYTHON_DECL object max(object const& a0); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +template +object min(A0 const& a0) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0)); +} +template +object min(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7), api_detail::get_arg(a8)); +} +template +object min(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::get_func("min")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2), api_detail::get_arg(a3), api_detail::get_arg(a4), api_detail::get_arg(a5), api_detail::get_arg(a6), api_detail::get_arg(a7), api_detail::get_arg(a8), api_detail::get_arg(a9)); +} +BOOST_PYTHON_DECL object min(object const& a0); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +template +object oct(A0 const& a0) +{ + return api_detail::get_func("oct")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object oct(object const& a0); +BOOST_PYTHON_DECL object oct(char a0); +BOOST_PYTHON_DECL object oct(short a0); +BOOST_PYTHON_DECL object oct(int a0); +BOOST_PYTHON_DECL object oct(long a0); +BOOST_PYTHON_DECL object open(object const& a0); +BOOST_PYTHON_DECL object open(const char* a0); +BOOST_PYTHON_DECL object open(object const& a0, object const& a1); +BOOST_PYTHON_DECL object open(const char* a0, const char* a1); +BOOST_PYTHON_DECL object open(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object open(const char* a0, const char* a1, int a2); +BOOST_PYTHON_DECL long ord(object const& a0); +BOOST_PYTHON_DECL long ord(const char* a0); +template +object pow(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("pow")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object pow(object const& a0, object const& a1); +BOOST_PYTHON_DECL object pow(double const& a0, double const& a1); +BOOST_PYTHON_DECL object pow(double const& a0, double const& a1, double const& a2); +template +object print(A0 const& a0) +{ + return api_detail::call_statement_du("print _1", use_new_dict, 1, (object const*)api_detail::get_arg(a0)); +} +template +object print(A0 const& a0, A1 const& a1) +{ + return api_detail::call_statement_du("print _1, _2", use_new_dict, 2, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::call_statement_du("print _1, _2, _3", use_new_dict, 3, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4", use_new_dict, 4, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5", use_new_dict, 5, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6", use_new_dict, 6, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8)); +} +template +object print(A0 const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, (object const*)api_detail::get_arg(a0), (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9)); +} +BOOST_PYTHON_DECL object print(object const& a0); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +template +object print_file(object const& a0, A1 const& a1) +{ + return api_detail::call_statement_du("print >>_1, _2", use_new_dict, 2, a0, (object const*)api_detail::get_arg(a1)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::call_statement_du("print >>_1, _2, _3", use_new_dict, 3, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4", use_new_dict, 4, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5", use_new_dict, 5, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6", use_new_dict, 6, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9)); +} +template +object print_file(object const& a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10) +{ + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11", use_new_dict, 11, a0, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9), (object const*)api_detail::get_arg(a10)); +} +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10); +template +object range(A0 const& a0) +{ + return api_detail::get_func("range")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object range(object const& a0); +BOOST_PYTHON_DECL object range(int a0); +template +object range(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("range")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object range(object const& a0, object const& a1); +BOOST_PYTHON_DECL object range(int a0, int a1); +template +object range(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::get_func("range")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2)); +} +BOOST_PYTHON_DECL object range(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object range(int a0, int a1, int a2); +BOOST_PYTHON_DECL object raw_input(); +BOOST_PYTHON_DECL object raw_input(object const& a0); +BOOST_PYTHON_DECL object raw_input(const char* a0); +BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1); +BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object reload(object const& a0); +BOOST_PYTHON_DECL object repr(object const& a0); +template +object round(A0 const& a0) +{ + return api_detail::get_func("round")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object round(object const& a0); +BOOST_PYTHON_DECL object round(double const& a0); +template +object round(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("round")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object round(object const& a0, object const& a1); +BOOST_PYTHON_DECL object round(double const& a0, double const& a1); +template +object slice(A0 const& a0) +{ + return api_detail::get_func("slice")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object slice(object const& a0); +BOOST_PYTHON_DECL object slice(int a0); +template +object slice(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("slice")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object slice(object const& a0, object const& a1); +BOOST_PYTHON_DECL object slice(int a0, int a1); +template +object slice(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::get_func("slice")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2)); +} +BOOST_PYTHON_DECL object slice(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object slice(int a0, int a1, int a2); +BOOST_PYTHON_DECL object str(object const& a0); +BOOST_PYTHON_DECL object tuple(); +BOOST_PYTHON_DECL object tuple(object const& a0); +BOOST_PYTHON_DECL object type_(object const& a0); +template +object unichr(A0 const& a0) +{ + return api_detail::get_func("unichr")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object unichr(object const& a0); +BOOST_PYTHON_DECL object unichr(short a0); +BOOST_PYTHON_DECL object unichr(int a0); +BOOST_PYTHON_DECL object unichr(long a0); +BOOST_PYTHON_DECL object unicode(object const& a0); +BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1); +BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1); +BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1, const char* a2); +BOOST_PYTHON_DECL object vars(); +BOOST_PYTHON_DECL object vars(object const& a0); +template +object xrange(A0 const& a0) +{ + return api_detail::get_func("xrange")(api_detail::get_arg(a0)); +} +BOOST_PYTHON_DECL object xrange(object const& a0); +BOOST_PYTHON_DECL object xrange(int a0); +template +object xrange(A0 const& a0, A1 const& a1) +{ + return api_detail::get_func("xrange")(api_detail::get_arg(a0), api_detail::get_arg(a1)); +} +BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1); +BOOST_PYTHON_DECL object xrange(int a0, int a1); +template +object xrange(A0 const& a0, A1 const& a1, A2 const& a2) +{ + return api_detail::get_func("xrange")(api_detail::get_arg(a0), api_detail::get_arg(a1), api_detail::get_arg(a2)); +} +BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object xrange(int a0, int a1, int a2); +BOOST_PYTHON_DECL object zip(object const& a0); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +BOOST_PYTHON_DECL object compile_string(const char* a0, const char* a1, int a2); +BOOST_PYTHON_DECL int import_append_inittab(const char* a0, void(*a1)(void)); +BOOST_PYTHON_DECL object import_add_module(const char* a0); +BOOST_PYTHON_DECL object import_get_module_dict(); +BOOST_PYTHON_DECL object import_import(object const& a0); +BOOST_PYTHON_DECL object import_import(const char* a0); +BOOST_PYTHON_DECL object import_import_module(const char* a0); +BOOST_PYTHON_DECL object import_import_module_ex(const char* a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object module_get_dict(object const& a0); +BOOST_PYTHON_DECL int object_print(object const& a0, FILE* a1, int a2); +BOOST_PYTHON_DECL object run_file(FILE* a0, const char* a1, int a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL int run_simple_file(FILE* a0, const char* a1); +BOOST_PYTHON_DECL int run_simple_string(const char* a0); +BOOST_PYTHON_DECL object run_string(const char* a0, int a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object call_statement(const char* a0); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1); +template +object call_statement(const char* a0, A1 const& a1) +{ + return api_detail::call_statement(a0, 1, (object const*)api_detail::get_arg(a1)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2) +{ + return api_detail::call_statement(a0, 2, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3) +{ + return api_detail::call_statement(a0, 3, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::call_statement(a0, 4, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::call_statement(a0, 5, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::call_statement(a0, 6, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::call_statement(a0, 7, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::call_statement(a0, 8, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::call_statement(a0, 9, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9)); +} +template +object call_statement(const char* a0, A1 const& a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10) +{ + return api_detail::call_statement(a0, 10, (object const*)api_detail::get_arg(a1), (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9), (object const*)api_detail::get_arg(a10)); +} +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10); +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2) +{ + return api_detail::call_statement_du(a0, a1, 1, (object const*)api_detail::get_arg(a2)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3) +{ + return api_detail::call_statement_du(a0, a1, 2, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4) +{ + return api_detail::call_statement_du(a0, a1, 3, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5) +{ + return api_detail::call_statement_du(a0, a1, 4, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6) +{ + return api_detail::call_statement_du(a0, a1, 5, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7) +{ + return api_detail::call_statement_du(a0, a1, 6, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8) +{ + return api_detail::call_statement_du(a0, a1, 7, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9) +{ + return api_detail::call_statement_du(a0, a1, 8, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10) +{ + return api_detail::call_statement_du(a0, a1, 9, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9), (object const*)api_detail::get_arg(a10)); +} +template +object call_statement(const char* a0, call_dict_usage a1, A2 const& a2, A3 const& a3, A4 const& a4, A5 const& a5, A6 const& a6, A7 const& a7, A8 const& a8, A9 const& a9, A10 const& a10, A11 const& a11) +{ + return api_detail::call_statement_du(a0, a1, 10, (object const*)api_detail::get_arg(a2), (object const*)api_detail::get_arg(a3), (object const*)api_detail::get_arg(a4), (object const*)api_detail::get_arg(a5), (object const*)api_detail::get_arg(a6), (object const*)api_detail::get_arg(a7), (object const*)api_detail::get_arg(a8), (object const*)api_detail::get_arg(a9), (object const*)api_detail::get_arg(a10), (object const*)api_detail::get_arg(a11)); +} +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10); +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10, object const& a11); + +}}} + +#endif // PY_INTERFACE_HPP + diff --git a/src/gen_py_api.py b/src/gen_py_api.py new file mode 100644 index 00000000..bc965d8f --- /dev/null +++ b/src/gen_py_api.py @@ -0,0 +1,776 @@ +# Copyright David Hawkes 2002. +# Permission is hereby granted to copy, use and modify this software +# for any purpose, including commercial distribution, provided this +# copyright notice is not removed. No warranty WHATSOEVER is provided with this +# software. Any user(s) accepts this software "as is" and as such they will not +# bind the author(s) to any claim of suitabilty for any purpose. + +# Build python API wrappers for boost python + +import re + +API_List = [ +'PyObject*{new} abs{direct}(int{template})', +'PyObject*{new} abs{direct}(PyObject*)', +'PyObject*{new} abs{direct}(short)', +'PyObject*{new} abs{direct}(int)', +'PyObject*{new} abs{direct}(long)', +'PyObject*{new} abs{direct}(double const &)', +'PyObject*{new,err=NULL} PyObject_CallObject{decl=apply}(PyObject*,PyObject*)', +'PyObject*{new,err=NULL} PyObject_Call{decl=apply}(PyObject*,PyObject*,PyObject*)', +'bool PyCallable_Check{decl=callable}(PyObject*)', +'PyObject*{new} chr{direct}(int{template})', +'PyObject*{new} chr{direct}(PyObject*)', +'PyObject*{new} chr{direct}(short)', +'PyObject*{new} chr{direct}(int)', +'PyObject*{new} chr{direct}(long)', +'int{err=-1} PyObject_Cmp{decl=cmp}(PyObject*{template},PyObject*{template},int{result})', +'int{err=-1} PyObject_Cmp{decl=cmp}(PyObject*,PyObject*,int{result})', +'PyObject*{new} coerce{direct}(PyObject*,PyObject*)', +'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} compile{direct}(const char*,const char*,const char*)', +'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*,PyObject*)', +'PyObject*{new} compile{direct}(const char*,const char*,const char*,int)', +'PyObject*{new} compile{direct}(PyObject*,PyObject*,PyObject*,PyObject*,PyObject*)', +'PyObject*{new} compile{direct}(const char*,const char*,const char*,int,int)', +'PyObject*{new} complex{direct}(int{template})', +'PyObject*{new} complex{direct}(PyObject*)', +'PyObject*{new} complex{direct}(double const&)', +'PyObject*{new} complex{direct}(int{template},int{template})', +'PyObject*{new} complex{direct}(PyObject*,PyObject*)', +'PyObject*{new} complex{direct}(double const&,double const&)', +'PyObject*{new} dict{direct}()', +'PyObject*{new} dict{direct}(PyObject*)', +'PyObject*{new} PyObject_Dir{decl=dir}(PyObject*{value=NULL})', +'PyObject*{new} PyObject_Dir{decl=dir}(PyObject*)', +'PyObject*{new} divmod{direct}(int{template},int{template})', +'PyObject*{new} divmod{direct}(PyObject*,PyObject*)', +'PyObject*{new} divmod{direct}(int,int)', +'PyObject*{new} divmod{direct}(long,long)', +'PyObject*{new} divmod{direct}(double const&,double const&)', +'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*{value=globals().ptr()},PyObject*{value=globals().ptr()})', +'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*,PyObject*{value=globals().ptr()})', +'PyObject*{new} PyRun_String{decl=eval}(char*{const},int{value=Py_eval_input},PyObject*,PyObject*)', +'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*{value=globals().ptr()},PyObject*{value=globals().ptr()})', +'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*,PyObject*{value=globals().ptr()})', +'PyObject*{new} PyRun_String{decl=exec}(char*{const},int{value=Py_file_input},PyObject*,PyObject*)', +'PyObject*{new} execfile{direct}(PyObject*)', +'PyObject*{new} execfile{direct}(PyObject*,PyObject*)', +'PyObject*{new} execfile{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} file{direct}(PyObject*)', +'PyObject*{new} file{direct}(const char*)', +'PyObject*{new} file{direct}(PyObject*,PyObject*)', +'PyObject*{new} file{direct}(const char*,const char*)', +'PyObject*{new} file{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} file{direct}(const char*,const char*,int)', +'PyObject*{new} filter{direct}(PyObject*,PyObject*)', +'PyObject*{new} float{direct,decl=float_}(PyObject*)', +'PyObject*{new} float{direct,decl=float_}(const char*)', +'PyObject*{new} float{direct,decl=float_}(double const&)', +'PyObject*{new} getattr{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} getattr{direct}(PyObject*,const char *,PyObject*)', +'PyObject*{borrowed,err=NULL} PyModule_GetDict{decl=globals}(PyObject*{value=PyImport_AddModule("__main__")})', +'bool PyObject_HasAttr{decl=hasattr}(PyObject*,PyObject*)', +'bool PyObject_HasAttrString{decl=hasattr}(PyObject*,char*{const})', +'long{err=-1} PyObject_Hash{decl=hash}(PyObject*)', +'PyObject*{new} hex{direct}(int{template})', +'PyObject*{new} hex{direct}(PyObject*)', +'PyObject*{new} hex{direct}(char)', +'PyObject*{new} hex{direct}(short)', +'PyObject*{new} hex{direct}(int)', +'PyObject*{new} hex{direct}(long)', +'long id{direct}(PyObject*)', +'PyObject*{new} input{direct}()', +'PyObject*{new} input{direct}(PyObject*)', +'PyObject*{new} input{direct}(const char*)', +'PyObject*{new} int{direct,decl=int_}(PyObject*)', +'PyObject*{new} int{direct,decl=int_}(long)', +'PyObject*{new} int{direct,decl=int_}(const char*)', +'PyObject*{new} intern{direct}(PyObject*)', +'PyObject*{new} intern{direct}(const char*)', +'bool PyObject_IsInstance{decl=isinstance}(PyObject*,PyObject*)', +'bool PyObject_IsSubclass{decl=issubclass}(PyObject*,PyObject*)', +'PyObject*{new} PyObject_GetIter{decl=iter}(PyObject*)', +'PyObject*{new} iter{direct}(PyObject*,PyObject*)', +'long{err=-1} PyObject_Length{decl=len}(PyObject*)', +'PyObject*{new} list{direct}()', +'PyObject*{new} list{direct}(PyObject*)', +'PyObject*{new} long{direct,decl=long_}(PyObject*)', +'PyObject*{new} long{direct,decl=long_}(long)', +'PyObject*{new} long{direct,decl=long_}(const char*)', +'PyObject*{new} map{direct,argrepeat}(PyObject*)', +'PyObject*{new} max{direct,argrepeat}(PyObject*{template})', +'PyObject*{new} max{direct,argrepeat}(PyObject*)', +'PyObject*{new} min{direct,argrepeat}(PyObject*{template})', +'PyObject*{new} min{direct,argrepeat}(PyObject*)', +'PyObject*{new} oct{direct}(int{template})', +'PyObject*{new} oct{direct}(PyObject*)', +'PyObject*{new} oct{direct}(char)', +'PyObject*{new} oct{direct}(short)', +'PyObject*{new} oct{direct}(int)', +'PyObject*{new} oct{direct}(long)', +'PyObject*{new} open{direct}(PyObject*)', +'PyObject*{new} open{direct}(const char*)', +'PyObject*{new} open{direct}(PyObject*,PyObject*)', +'PyObject*{new} open{direct}(const char*,const char*)', +'PyObject*{new} open{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} open{direct}(const char*,const char*,int)', +'long ord{direct}(PyObject*)', +'long ord{direct}(const char*)', +'PyObject*{new} pow{direct}(int{template},int{template})', +'PyObject*{new} pow{direct}(PyObject*,PyObject*)', +'PyObject*{new} pow{direct}(double const&,double const&)', +'PyObject*{new} pow{direct}(double const&,double const&,double const&)', +'PyObject*{new} print{direct,statement=print _1,argrepeat}(int{template})', +'PyObject*{new} print{direct,statement=print _1,argrepeat}(PyObject*)', +'PyObject*{new} print{decl=print_file,direct,statement="print >>_1, _2",argrepeat}(PyObject*,int{template})', +'PyObject*{new} print{decl=print_file,direct,statement="print >>_1, _2",argrepeat}(PyObject*,PyObject*)', +'PyObject*{new} range{direct}(int{template})', +'PyObject*{new} range{direct}(PyObject*)', +'PyObject*{new} range{direct}(int)', +'PyObject*{new} range{direct}(int{template},int{template})', +'PyObject*{new} range{direct}(PyObject*,PyObject*)', +'PyObject*{new} range{direct}(int,int)', +'PyObject*{new} range{direct}(int{template},int{template},int{template})', +'PyObject*{new} range{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} range{direct}(int,int,int)', +'PyObject*{new} raw_input{direct}()', +'PyObject*{new} raw_input{direct}(PyObject*)', +'PyObject*{new} raw_input{direct}(const char*)', +'PyObject*{new} reduce{direct}(PyObject*,PyObject*)', +'PyObject*{new} reduce{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new,err=NULL} PyImport_ReloadModule{decl=reload}(PyObject*)', +'PyObject*{new} PyObject_Repr{decl=repr}(PyObject*)', +'PyObject*{new} round{direct}(int{template})', +'PyObject*{new} round{direct}(PyObject*)', +'PyObject*{new} round{direct}(double const&)', +'PyObject*{new} round{direct}(int{template},int{template})', +'PyObject*{new} round{direct}(PyObject*,PyObject*)', +'PyObject*{new} round{direct}(double const&,double const&)', +'PyObject*{new} slice{direct}(int{template})', +'PyObject*{new} slice{direct}(PyObject*)', +'PyObject*{new} slice{direct}(int)', +'PyObject*{new} slice{direct}(int{template},int{template})', +'PyObject*{new} slice{direct}(PyObject*,PyObject*)', +'PyObject*{new} slice{direct}(int,int)', +'PyObject*{new} slice{direct}(int{template},int{template},int{template})', +'PyObject*{new} slice{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} slice{direct}(int,int,int)', +'PyObject*{new} PyObject_Str{decl=str}(PyObject*)', +'PyObject*{new} tuple{direct}()', +'PyObject*{new} tuple{direct}(PyObject*)', +'PyObject*{new,err=NULL} PyObject_Type{decl=type_}(PyObject*)', +'PyObject*{new} unichr{direct}(int{template})', +'PyObject*{new} unichr{direct}(PyObject*)', +'PyObject*{new} unichr{direct}(short)', +'PyObject*{new} unichr{direct}(int)', +'PyObject*{new} unichr{direct}(long)', +'PyObject*{new} PyObject_Unicode{decl=unicode}(PyObject*)', +'PyObject*{new} unicode{direct}(PyObject*,PyObject*)', +'PyObject*{new} unicode{direct}(PyObject*,const char*)', +'PyObject*{new} unicode{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} unicode{direct}(PyObject*,const char*,const char*)', +'PyObject*{new} vars{direct}()', +'PyObject*{new} vars{direct}(PyObject*)', +'PyObject*{new} xrange{direct}(int{template})', +'PyObject*{new} xrange{direct}(PyObject*)', +'PyObject*{new} xrange{direct}(int)', +'PyObject*{new} xrange{direct}(int{template},int{template})', +'PyObject*{new} xrange{direct}(PyObject*,PyObject*)', +'PyObject*{new} xrange{direct}(int,int)', +'PyObject*{new} xrange{direct}(int{template},int{template},int{template})', +'PyObject*{new} xrange{direct}(PyObject*,PyObject*,PyObject*)', +'PyObject*{new} xrange{direct}(int,int,int)', +'PyObject*{new} zip{direct,argrepeat}(PyObject*)', +'PyObject*{new,err=NULL} Py_CompileString{decl=compile_string}(char*{const},char*{const},int)', +'int{err=-1} PyImport_AppendInittab{decl=import_append_inittab}(char*{const},void(*arg)(void))', +'PyObject*{borrowed,err=NULL} PyImport_AddModule{decl=import_add_module}(char*{const})', +'PyObject*{borrowed,err=NULL} PyImport_GetModuleDict{decl=import_get_module_dict}()', +'PyObject*{new,err=NULL} PyImport_Import{decl=import_import}(PyObject*)', +'PyObject*{new,err=NULL} PyImport_Import{decl=import_import}(const char*{object})', +'PyObject*{new,err=NULL} PyImport_ImportModule{decl=import_import_module}(char*{const})', +'PyObject*{new,err=NULL} PyImport_ImportModuleEx{decl=import_import_module_ex}(char*{const},PyObject*,PyObject*,PyObject*)', +'PyObject*{borrowed,err=NULL} PyModule_GetDict{decl=module_get_dict}(PyObject*)', +'int{err=-1} PyObject_Print{decl=object_print}(PyObject*,FILE*,int)', +'PyObject*{new,err=NULL} PyRun_File{decl=run_file}(FILE*,char*{const},int,PyObject*,PyObject*)', +'int{err=-1} PyRun_SimpleFile{decl=run_simple_file}(FILE*,char*{const})', +'int{err=-1} PyRun_SimpleString{decl=run_simple_string}(char*{const})', +'PyObject*{new,err=NULL} PyRun_String{decl=run_string}(char*{const},int,PyObject*,PyObject*)', +'PyObject*{new} call_statement{statement,direct}(const char*{statement})', +'PyObject*{new} call_statement{statement,direct}(const char*{statement},call_dict_usage{use_gd})', +'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},int{template})', +'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},PyObject*)', +'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},call_dict_usage{use_gd},int{template})', +'PyObject*{new} call_statement{argrepeat,statement,direct}(const char*{statement},call_dict_usage{use_gd},PyObject*)', +] + +DeclFile = '../../../boost/python/py_interface.hpp' +ImplFile = 'py_interface.cpp' + +DeclFileHeader = '''\ +// Automatically generated from py_api_gen.py +#ifndef PY_INTERFACE_HPP +#define PY_INTERFACE_HPP + +#include +#include + +namespace boost { namespace python { namespace api { + +enum call_dict_usage { use_new_dict, use_local_dict, use_global_dict }; + +namespace api_detail { + +BOOST_PYTHON_DECL object get_func(const char* name); +BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...); +BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...); + +template +struct get_arg +{ + get_arg(A const &a) : h(a) {} + object h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +template<> +struct get_arg +{ + get_arg(object const &a) : h(a) {} + object const &h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +template<> +struct get_arg +{ + get_arg(PyObject* a) : h((python::detail::borrowed_reference)a) {} + object h; + operator object const& () { return h; } + operator object const* () { return &h; } +}; + +} + +BOOST_PYTHON_DECL object locals(); + +''' + +DeclFileTrailer = '''\ +}}} + +#endif // PY_INTERFACE_HPP +''' + +ImplFileHeader = '''\ +// Automatically generated from py_api_gen.py + +#include + +namespace boost { namespace python { namespace api { + +namespace api_detail { + +BOOST_PYTHON_DECL object get_func(const char* name) { + object __builtin__((python::detail::borrowed_reference)::PyImport_AddModule(const_cast("__builtin__"))); + return object(__builtin__.attr(name)); +} + +inline handle<> get_current_frame() +{ + return handle<>(allow_null(borrowed((PyObject*)(PyThreadState_Get()->frame)))); +} + +inline object get_global_dict(call_dict_usage cdu, handle<> const& frame) +{ + if(frame.get()) + return object(object(frame).attr("f_globals")); + else + return api::globals(); +} + +object get_local_dict(call_dict_usage cdu, handle<> const& frame, object const& global_dict) +{ + switch(cdu) { + case use_new_dict: + return api::dict(); + case use_global_dict: + return global_dict; + default: + if(frame.get()) + return object(object(frame).attr("f_locals")); + else + return api::dict(); + } +} + +inline object call_statement(const char *stmt, object const& global_dict, object& local_dict) +{ + local_dict["_0"] = object((python::detail::borrowed_reference)Py_None); + api::run_string(stmt, Py_file_input, global_dict, local_dict); + return object(local_dict["_0"]); +} + +object call_statement(const char *stmt) +{ + handle<> frame(get_current_frame()); + if(frame.get()) { + object f(frame); + object gd(f.attr("f_globals")); + object ld(f.attr("f_locals")); + return call_statement(stmt, gd, ld); + } else { + object gd(api::globals()); + object ld(api::dict()); + return call_statement(stmt, gd, ld); + } +} + +object call_statement_du(const char *stmt, call_dict_usage cdu) +{ + handle<> frame(get_current_frame()); + object gd(get_global_dict(cdu, frame)); + return call_statement(stmt, gd, get_local_dict(cdu, frame, gd)); +} + +inline object call_statement(const char *stmt, object const& global_dict, object& local_dict, int n, va_list mk) +{ + static const char *(idx[]) = { "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9", "_10" }; + local_dict["_0"] = object((python::detail::borrowed_reference)Py_None); + for(int i = 0; i < n; ++i) + { + object const* p_arg = va_arg(mk, object const*); + object const& arg = *p_arg; + if(i < (int) (sizeof(idx) / sizeof(idx[0]))) + local_dict[idx[i]] = arg; + else { + local_dict[object("_") + object((python::detail::new_reference)PyObject_Str(object(i + 1).ptr()))] = arg; + } + } + va_end(mk); + api::run_string(stmt, Py_file_input, global_dict, local_dict); + return object(local_dict["_0"]); +} + +BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...) +{ + va_list mk; + va_start(mk, n); + handle<> frame(get_current_frame()); + if(frame.get()) { + object f(frame); + object gd(f.attr("f_globals")); + object ld(f.attr("f_locals")); + return call_statement(stmt, gd, ld, n, mk); + } else { + object gd(api::globals()); + object ld(api::dict()); + return call_statement(stmt, gd, ld, n, mk); + } +} + +BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...) +{ + handle<> frame(get_current_frame()); + object gd(get_global_dict(cdu, frame)); + va_list mk; + va_start(mk, n); + return call_statement(stmt, gd, get_local_dict(cdu, frame, gd), n, mk); +} + +} + +BOOST_PYTHON_DECL object locals() +{ + handle<> frame(api_detail::get_current_frame()); + if(frame.get()) + return object(object(frame).attr("f_locals")); + else + return api::dict(); +} + +''' + +ImplFileTrailer = '''\ +}}} +''' + +def SplitOutList(l): + vals_list = [] + if l == None: + return vals_list + vals_list = re.findall(r'((?:[^,{}]|(?:{[^{}]*}))+),?\s*', l) + return vals_list + +def SplitOutListDict(l): + vals_dict = {} + if l == None: + return vals_dict + vals = re.findall(r'((?:"[^"]+"|[^,"]+)+)\s*,?', l) + for val in vals: + m = re.match(r'(?P[^\s=]+)\s*(=\s*(?P"?)(?P.+)(?P=qt))?', val).groupdict() + vals_dict[m['aname']] = m['aval'] + return vals_dict + +def SplitOutAttrs(a): + soa = {} + m = re.match(r'(?P[^{]+)({(?P[^}]+)})?', a).groupdict() + soa['name'] = m['name'] + soa.update(SplitOutListDict(m['attrs'])) + return soa + +def is_object(name): + if re.match(r'PyObject\s*\*', name['name']): + return 1 + return 0 + +def is_arg_really_const(arg): + return arg.has_key('const') + +def get_actual_rtn_type(rtn, args): + i = 0 + for a in args: + if a.has_key('result'): + true_rtn = dict(rtn) + true_rtn['name'] = a['name'] + true_rtn['arg_number'] = i + return true_rtn + i += 1 + return rtn + +def is_template(name): + return name.has_key('template') + +def decl_func_arg(arg, p): + if arg.has_key('value'): + return '' + elif arg.has_key('result'): + return '' + elif is_object(arg): + if is_template(arg): + sn = str(p) + return 'A' + sn +' const& a' + sn + else: + return 'object const& a' + str(p) + elif is_arg_really_const(arg): + return 'const ' + arg['name'] + ' a' + str(p) + elif re.search(r'arg', arg['name']): + return re.sub(r'arg', 'a' + str(p), arg['name']) + else: + if is_template(arg): + sn = str(p) + return 'A' + sn +' const& a' + sn + else: + return arg['name'] + ' a' + str(p) + +def decl_func_args(name, args): + if not len(args): + return '' + d_args = reduce(lambda x,y : x + (y and (', ' + y) or ''), map(decl_func_arg, args, xrange(len(args)))) + return d_args + +def call_func_arg(arg, p): + if arg.has_key('value'): + return arg['value'] + elif arg.has_key('result'): + return '&rslt' + elif arg.has_key('template'): + sn = str(p) + return 'api_detail::get_arg(a%s)' % (sn, sn) + elif arg.has_key('object'): + return 'object(a%s).ptr()' % str(p) + elif is_object(arg): + return 'a' + str(p) + '.ptr()' + elif is_arg_really_const(arg): + return 'const_cast<%s>(%s)' % (arg['name'], 'a' + str(p)) + else: + return 'a' + str(p) + +def call_func_args(args): + if not len(args): + return '' + d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(call_func_arg, args, xrange(len(args)))) + return d_args + +def call_func(name, args): + return '::%s(%s)' % (name['name'], call_func_args(args)) + +def call_func_direct_arg(arg, p): + if arg.has_key('use_gd'): + return '' + elif arg.has_key('statement'): + return '' + elif arg.has_key('value'): + return arg['value'] + elif arg.has_key('template'): + sn = str(p) + if arg.has_key('addr'): + return '(object const*)api_detail::get_arg(a%s)' % (sn, sn) + else: + return 'api_detail::get_arg(a%s)' % (sn, sn) + elif is_object(arg): + if arg.has_key('addr'): + return '&a' + str(p) + else: + return 'a' + str(p) + else: + if arg.has_key('addr'): + return '&object(a%s)' % str(p) + else: + return 'object(a%s)' % str(p) + +def call_func_direct_args(args): + if not len(args): + return '' + d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(call_func_direct_arg, args, xrange(len(args)))) + return d_args + +def get_statement_arg(args): + i = 0 + for arg in args: + if arg.has_key('statement'): + return i + i = i + 1 + return -1 + +def get_use_gd_arg(args): + i = 0 + for arg in args: + if arg.has_key('use_gd'): + return i + i = i + 1 + return -1 + +def call_func_direct(name, args): + if name.has_key('statement'): + na = len(args) + ugd = get_use_gd_arg(args) + sa = get_statement_arg(args) + if ugd >= 0: + ugd = 'a' + str(ugd) + na = na - 1 + else: + if (sa < 0) and (na > 0): + ugd = 'use_new_dict' + else: + ugd = None + if sa >= 0: + na = na - 1 + if na > 0: + if ugd: + return 'api_detail::call_statement_du(%s, %s, %s, %s)' % ('a' + str(sa), ugd, na, call_func_direct_args(args)) + else: + return 'api_detail::call_statement(%s, %s, %s)' % ('a' + str(sa), na, call_func_direct_args(args)) + else: + if ugd: + return 'api_detail::call_statement_du(%s, %s)' % ('a' + str(sa), ugd) + else: + return 'api_detail::call_statement(%s)' % ('a' + str(sa)) + else: + if na > 0: + if ugd: + return 'api_detail::call_statement_du("%s", %s, %s, %s)' % (name['statement'], ugd, na, call_func_direct_args(args)) + else: + return 'api_detail::call_statement("%s", %s, %s)' % (name['statement'], na, call_func_direct_args(args)) + else: + if ugd: + return 'api_detail::call_statement_du("%s", %s)' % (name['statement'], ugd) + else: + return 'api_detail::call_statement("%s")' % (name['statement']) + else: + return 'api_detail::get_func("%s")(%s)' % (name['name'], call_func_direct_args(args)) + +def decl_template_arg(arg, p): + if arg.has_key('value'): + return '' + elif arg.has_key('result'): + return '' + elif is_template(arg): + return 'class A' + str(p) + else: + return '' + +def decl_template_args(args): + if not len(args): + return '' + d_args = reduce(lambda x,y : x + (y and ((x and ', ' or '') + y) or ''), map(decl_template_arg, args, xrange(len(args)))) + return d_args + +def is_rtn_borrowed_object(rtn): + if is_object(rtn): + return rtn.has_key('borrowed') + else: + return 0 + +def is_rtn_new_object(rtn): + if is_object(rtn): + return not rtn.has_key('borrowed') + else: + return 0 + +def is_func_direct(name): + return name.has_key('direct') + +def rtn_call_func_direct(rtn, name, args): + if rtn['name'] == 'void': + direct_code = ' %s;' % call_func_direct(name, args) + elif is_object(rtn): + direct_code = ' return %s;' % call_func_direct(name, args) + else: + r = '''\ + object r(%s); + return boost::python::arg_from_python<%s>(r.ptr())(r.ptr());''' + direct_code = r % (call_func_direct(name, args), rtn['name']) + return direct_code + +def rtn_call_func(rtn, name, args): + if is_func_direct(name): + return rtn_call_func_direct(rtn, name, args) + true_rtn = get_actual_rtn_type(rtn, args) + err = true_rtn.get('err') + arg_number = true_rtn.get('arg_number') + if rtn['name'] == 'void': + return ' %s;' % call_func(name, args) + elif is_rtn_new_object(rtn): + if err and (err != 'NULL'): + r = '''\ + PyObject* r = %s; + if(r == %s) + throw_error_already_set(); + return object((python::detail::new_reference)r);''' + return r % (call_func(name, args), err) + else: + return ' return object((python::detail::new_reference)%s);' % call_func(name, args) + elif is_rtn_borrowed_object(rtn): + if err and (err != 'NULL'): + r = '''\ + PyObject* r = %s; + if(r == %s) + throw_error_already_set(); + return object((python::detail::borrowed_reference)r);''' + return r % (call_func(name, args), err) + else: + return ' return object((python::detail::borrowed_reference)%s);' % call_func(name, args) + else: + if err: + if arg_number == None: + r = '''\ + %s r = %s; + if(r == %s) + throw_error_already_set(); + return r;''' + return r % (rtn['name'], call_func(name, args), err) + else: + r = '''\ + %s rslt; + %s r = %s; + if(r == %s) + throw_error_already_set(); + return rslt;''' + return r % (true_rtn['name'], rtn['name'], call_func(name, args), err) + else: + return ' return %s;' % call_func(name, args) + +def decl_func(name, args): + return '%s(%s)' % (name.get('decl', name['name']), decl_func_args(name, args)) + +def rtn_decl_func(rtn, name, args): + true_rtn = get_actual_rtn_type(rtn, args) + ta = decl_template_args(args) + if ta: + decl = 'template<%s>\n' % ta + else: + decl = 'BOOST_PYTHON_DECL ' + if is_object(true_rtn): + return decl + 'object %s' % decl_func(name, args) + else: + return decl + '%s %s' % (true_rtn['name'], decl_func(name, args)) + +def is_info_template(fn_info): + for arg in fn_info['args']: + if is_template(arg): + return 1 + return 0 + +def parse_func(func): + fn_info = {} + fnm = re.match(r'(?P\S+)\s+(?P[^\s\(\){}]+({[^{}]*})?)\s*\((?P(({[^{}]*})+|(\([^\(\)]*\))+|[^\(\)]+)*)\)', func).groupdict() + fn_info['fname'] = SplitOutAttrs(fnm['fname']) + fn_info['rtn'] = SplitOutAttrs(fnm['rtn']) + fn_info['args'] = map(SplitOutAttrs, SplitOutList(fnm['args'])) + if fn_info['fname'].has_key('statement'): + if is_info_template(fn_info): + for arg in fn_info['args']: + if is_template(arg): + arg['addr'] = None + else: + for arg in fn_info['args']: + if is_object(arg): + arg['addr'] = None + return fn_info + +def get_argrepeat(fn_info): + if fn_info['fname'].has_key('argrepeat'): + argrepeat = fn_info['fname']['argrepeat'] + if argrepeat == None: + argrepeat = 10 + else: + argrepeat = 1 + return argrepeat + +def do_arg_repeat(fn_info): + fn_info['args'] = fn_info['args'] + [fn_info['args'][len(fn_info['args']) - 1],] + if fn_info['fname'].has_key('statement'): + stmt = fn_info['fname']['statement'] + if stmt: + s_args = re.findall(r'[\s,\(](?:_([0-9]+))(?=$|[\s,\)])', stmt) + if s_args: + mx = reduce(max, map(int, s_args), 0) + mx_arg = '_' + str(mx) + next_arg = '_' + str(mx + 1) + stmt = re.sub(r'(?<=[\s,\(])' + mx_arg + '(?=$|[\s,\)])', mx_arg + ', ' + next_arg, stmt, 1) + fn_info['fname']['statement'] = stmt + +def decl_funcs(fn_list): + fn_defs = '' + for fn in fn_list: + fn_info = parse_func(fn) + argrepeat = get_argrepeat(fn_info) + for ar in xrange(argrepeat): + fn_defs += rtn_decl_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + if is_info_template(fn_info): + fn_defs += '\n{\n' + rtn_call_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + '\n}\n' + else: + fn_defs += ';\n' + if ar != (argrepeat - 1): + do_arg_repeat(fn_info) + return fn_defs + +def impl_funcs(fn_list): + fn_defs = '' + for fn in fn_list: + fn_info = parse_func(fn) + if is_info_template(fn_info): + continue + argrepeat = get_argrepeat(fn_info) + for ar in xrange(argrepeat): + fn_defs += rtn_decl_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + ' {\n' + fn_defs += rtn_call_func(fn_info['rtn'], fn_info['fname'], fn_info['args']) + '\n}\n\n' + if ar != (argrepeat - 1): + do_arg_repeat(fn_info) + return fn_defs + +if __name__ == '__main__': + f = file(DeclFile, 'w') + print >>f, DeclFileHeader + print >>f, decl_funcs(API_List) + print >>f, DeclFileTrailer + f.close() + + f = file(ImplFile, 'w') + print >>f, ImplFileHeader + print >>f, impl_funcs(API_List) + print >>f, ImplFileTrailer + f.close() diff --git a/src/module.cpp b/src/module.cpp index f7edf39e..9fe86adf 100644 --- a/src/module.cpp +++ b/src/module.cpp @@ -7,16 +7,107 @@ // producing this work. #include +#include +#include #include +#include #include namespace boost { namespace python { namespace detail { -module_base::module_base(const char* name) - : m_module( - python::borrowed(Py_InitModule(const_cast(name), initial_methods)) - ) +namespace { + +object getattr_or_none(object const &obj, const char *name) { + if(PyObject_HasAttrString(obj.ptr(), const_cast(name))) + return obj.attr(name); + else + return object(); +} + +// Initialise a new sub-module, or return an existing one. +// This will also create any missing parents along the way. +handle<> init_sub_module(const char* name, PyMethodDef *initial_methods, module_info* pmi) +{ + if(name == NULL) + // just create a dummy module with an empty reference + return handle<>(); + // initialise various iterators, etc. + object parent_module(pmi->get_module()), current_module(parent_module); + std::string s_name(name), b_name; + if(s_name.size() == 0) + // use the default module name if it is not supplied + s_name = pmi->get_module_name(); + std::string::size_type p_pos(0); + for(int l = 0;;++l) { + // find the next module name in the 'dotted' name + std::string::size_type dot_pos = s_name.find('.', p_pos); + // p_pos is the absolute position, but the length is needed + if(dot_pos != std::string::npos) + dot_pos -= p_pos; + // the current module name being processed, iterating from the parent + // to the right hand sub-modules + b_name = s_name.substr(p_pos, dot_pos); + if(l == 0) { + // process the top level parent module name + if(dot_pos == 0) + // allow a shortcut module notation so we can do module(".submodule") + b_name = pmi->get_module_name(); + // check the base name is the correct parent name else assert + assert(b_name.compare(pmi->get_module_name()) == 0); + if(!parent_module) { + // The main parent module does not exist yet, so create it here + parent_module = object(python::borrowed(Py_InitModule( + const_cast(b_name.c_str()), + initial_methods))); + // and set up the module iterator + current_module = parent_module; + // initialise the global parent module so it can be found later + pmi->set_module(parent_module); + } + } else { + // now processing a sub-module + // try to find and verify an existing sub-module of the correct name and type + object existing_sub_module(getattr_or_none(current_module, b_name.c_str())); + if(existing_sub_module) { + // An attribute of the same name has been found + object module_type((python::detail::new_reference)PyObject_Type(parent_module.ptr())); + // test its type against the parent + if(!PyObject_IsSubclass(existing_sub_module.ptr(), module_type.ptr())) + // not actually a module, so it can't be used + existing_sub_module = object(); + } + // was an existing sub-module found ? + if(!existing_sub_module) { + // no, then it is created here + // build up the full path name up to and including the current sub-module + std::string full_name(s_name.substr(0, dot_pos)); + // create the module + existing_sub_module = object(python::borrowed(Py_InitModule( + const_cast(full_name.c_str()), + initial_methods))); + // add the sub-module to the attributes of its immediate parent + current_module.attr(b_name.c_str()) = existing_sub_module; + } + // we now have a new current module to iterate + current_module = existing_sub_module; + } + // no more modules ? + if(dot_pos == std::string::npos) + break; + // advance over the dot + p_pos += dot_pos + 1; + } + // return the actual sub-module that was either found or created + return handle<>(python::borrowed(current_module.ptr())); +} + +} + +module_base::module_base(const char* name) + : m_module(init_sub_module(name, initial_methods, get_module_info())) +{ + set_prior_module(m_module); } module_base::~module_base() @@ -42,7 +133,16 @@ void module_base::add(type_handle const& x) void module_base::add_class(type_handle const& class_obj) { - this->add(class_obj); + add_class(class_obj, objects::class_base:: + get_class_context_object(class_obj.get()->tp_name, class_obj)); +} + +void module_base::add_class(type_handle const& class_obj, handle<> const& context) +{ + if(context.get()) { + objects::function:: + add_to_namespace(context, ((PyTypeObject*)class_obj.get())->tp_name, class_obj); + } handle<> module_name( PyObject_GetAttrString( @@ -50,13 +150,38 @@ void module_base::add_class(type_handle const& class_obj) ); int status = PyObject_SetAttrString( - python::upcast(class_obj.get()) - , const_cast("__module__"), module_name.get()); + handle<>(class_obj).get(), const_cast("__module__"), module_name.get()); if (status == -1) throw_error_already_set(); } +void module_base::set_module_info(module_info & mi) +{ + get_module_info_ref() = &mi; +} + +module_info* module_base::get_module_info() +{ + return get_module_info_ref(); +} + +module_info*& module_base::get_module_info_ref() +{ + static module_info* pmi = NULL; + return pmi; +} + +void module_base::set_prior_module(handle<> const& m) +{ + get_module_info()->set_prior_module(python::object(m)); +} + +handle<> module_base::get_prior_module() +{ + return handle<>(python::borrowed(get_module_info()->get_prior_module().ptr())); +} + PyMethodDef module_base::initial_methods[] = { { 0, 0, 0, 0 } }; }}} // namespace boost::python::detail diff --git a/src/object/class.cpp b/src/object/class.cpp index e49df96f..f2c602f6 100644 --- a/src/object/class.cpp +++ b/src/object/class.cpp @@ -3,10 +3,13 @@ // 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. +#include #include #include #include #include +#include +#include #include #include #include @@ -246,6 +249,12 @@ namespace objects char const* name, std::size_t num_types, class_id const* const types) { assert(num_types >= 1); + + // is this class already registered? + m_object = query_class(types[0]); + if(m_object.get()) { + return; + } // Build a tuple of the base Python type objects. If no bases // were declared, we'll use our class_type() as the single base @@ -260,9 +269,15 @@ namespace objects PyTuple_SET_ITEM(bases.get(), i - 1, upcast(c.release())); } + // we now need just the base name + std::string base_name(name); + std::string::size_type dot_pos = base_name.rfind('.'); + if(dot_pos != std::string::npos) + base_name = base_name.substr(dot_pos + 1); + // Build the (name, bases, dict) tuple for creating the new class handle<> args(PyTuple_New(3)); - PyTuple_SET_ITEM(args.get(), 0, incref(python::object(name).ptr())); + PyTuple_SET_ITEM(args.get(), 0, incref(python::object(base_name.c_str()).ptr())); PyTuple_SET_ITEM(args.get(), 1, bases.release()); handle<> d(PyDict_New()); PyTuple_SET_ITEM(args.get(), 2, d.release()); @@ -304,9 +319,107 @@ namespace objects throw_error_already_set(); } + namespace { + class empty_class {}; + + void transfer_attributes(object const& src, object const& dst) + { + object attrs((python::detail::new_reference)PyObject_Dir(src.ptr())); + if(PyList_Check(attrs.ptr())) { + int sz = PyList_Size(attrs.ptr()); + for(int i = 0; i < sz; i++) { + PyObject *attr_name = PyList_GET_ITEM(attrs.ptr(), i); + object attr((python::detail::new_reference)PyObject_GetAttr(src.ptr(), attr_name)); + // only transfer boost classes + if(attr.ptr()->ob_type == &class_metatype_object) + PyObject_SetAttr(dst.ptr(), attr_name, attr.ptr()); + } + } + } + + + object getattr_or_none(object const &obj, const char *name) + { + if(PyObject_HasAttrString(obj.ptr(), const_cast(name))) + return obj.attr(name); + else + return object(); + } + + } + + // get a class context for nested classes + handle<> class_base::get_class_context_object(const char* name, type_handle const& class_obj) + { + // initialise various iterators, etc. + std::string s_name(name), b_name; + std::string::size_type p_pos(0); + python::object current_object(python::detail::module_base::get_prior_module()); + for(;;) { + // find the next class name in the 'dotted' name + std::string::size_type dot_pos = s_name.find('.', p_pos); + // have we completed up to the current class ? + // p_pos is the absolute position, but the length is needed + if(dot_pos != std::string::npos) + dot_pos -= p_pos; + // the current class name being processed, iterating from left to right + b_name = s_name.substr(p_pos, dot_pos); + if(dot_pos == std::string::npos) { + // this is the last class in the chain, is it here already + python::object existing_object(getattr_or_none(current_object, b_name.c_str())); + if(existing_object) { + // yes + if(PyObject_TypeCheck(existing_object.ptr(), &PyType_Type)) { + PyTypeObject *pType = (PyTypeObject *) existing_object.ptr(); + // is it one of ours? + if(pType->ob_type == &class_metatype_object) { + // then lets see if its our empty_class + type_handle r = query_class(python::type_id()); + // is it registered as the empty_class? + if(r.get() == pType) { + // yes, then we can transfer attributes + transfer_attributes(python::object(handle<>(r)), python::object(handle<>(class_obj))); + } else { + // the user must have created it already. + // so we don't need to add it + return handle<>(); + } + } + } + } + break; + } + // try to find an existing parent of the nested class + current_object = getattr_or_none(current_object, b_name.c_str()); + if(!current_object) { + // If we can't find it then insert a temporary class as a marker + std::string full_name(s_name.substr(0, dot_pos)); + current_object = python::object(handle<>(boost::python::class_(full_name.c_str()).object())); + } + // we now have a new current object to iterate + // note that we could attach the nested class to something other + // than a parent class here as we are not testing the type, + // does this really matter? + // advance over the dot + p_pos += dot_pos + 1; + } + // return the actual sub-module that was either found or created + return handle<>(python::borrowed(current_object.ptr())); + } + + class_base::class_base() + { + } + + class_base const& class_base::empty_class_base() + { + static class_base ecb; + return ecb; + } + BOOST_PYTHON_DECL type_handle registered_class_object(class_id id) { - return objects::query_class(id); + return query_class(id); } } // namespace objects diff --git a/src/py_interface.cpp b/src/py_interface.cpp new file mode 100644 index 00000000..e34bf6f9 --- /dev/null +++ b/src/py_interface.cpp @@ -0,0 +1,1103 @@ +// Automatically generated from py_api_gen.py + +#include + +namespace boost { namespace python { namespace api { + +namespace api_detail { + +BOOST_PYTHON_DECL object get_func(const char* name) { + object __builtin__((python::detail::borrowed_reference)::PyImport_AddModule(const_cast("__builtin__"))); + return object(__builtin__.attr(name)); +} + +inline handle<> get_current_frame() +{ + return handle<>(allow_null(borrowed((PyObject*)(PyThreadState_Get()->frame)))); +} + +inline object get_global_dict(call_dict_usage cdu, handle<> const& frame) +{ + if(frame.get()) + return object(object(frame).attr("f_globals")); + else + return api::globals(); +} + +object get_local_dict(call_dict_usage cdu, handle<> const& frame, object const& global_dict) +{ + switch(cdu) { + case use_new_dict: + return api::dict(); + case use_global_dict: + return global_dict; + default: + if(frame.get()) + return object(object(frame).attr("f_locals")); + else + return api::dict(); + } +} + +inline object call_statement(const char *stmt, object const& global_dict, object& local_dict) +{ + local_dict["_0"] = object((python::detail::borrowed_reference)Py_None); + api::run_string(stmt, Py_file_input, global_dict, local_dict); + return object(local_dict["_0"]); +} + +object call_statement(const char *stmt) +{ + handle<> frame(get_current_frame()); + if(frame.get()) { + object f(frame); + object gd(f.attr("f_globals")); + object ld(f.attr("f_locals")); + return call_statement(stmt, gd, ld); + } else { + object gd(api::globals()); + object ld(api::dict()); + return call_statement(stmt, gd, ld); + } +} + +object call_statement_du(const char *stmt, call_dict_usage cdu) +{ + handle<> frame(get_current_frame()); + object gd(get_global_dict(cdu, frame)); + return call_statement(stmt, gd, get_local_dict(cdu, frame, gd)); +} + +inline object call_statement(const char *stmt, object const& global_dict, object& local_dict, int n, va_list mk) +{ + static const char *(idx[]) = { "_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9", "_10" }; + local_dict["_0"] = object((python::detail::borrowed_reference)Py_None); + for(int i = 0; i < n; ++i) + { + object const* p_arg = va_arg(mk, object const*); + object const& arg = *p_arg; + if(i < (int) (sizeof(idx) / sizeof(idx[0]))) + local_dict[idx[i]] = arg; + else { + local_dict[object("_") + object((python::detail::new_reference)PyObject_Str(object(i + 1).ptr()))] = arg; + } + } + va_end(mk); + api::run_string(stmt, Py_file_input, global_dict, local_dict); + return object(local_dict["_0"]); +} + +BOOST_PYTHON_DECL object call_statement(const char *stmt, int n, ...) +{ + va_list mk; + va_start(mk, n); + handle<> frame(get_current_frame()); + if(frame.get()) { + object f(frame); + object gd(f.attr("f_globals")); + object ld(f.attr("f_locals")); + return call_statement(stmt, gd, ld, n, mk); + } else { + object gd(api::globals()); + object ld(api::dict()); + return call_statement(stmt, gd, ld, n, mk); + } +} + +BOOST_PYTHON_DECL object call_statement_du(const char *stmt, call_dict_usage cdu, int n, ...) +{ + handle<> frame(get_current_frame()); + object gd(get_global_dict(cdu, frame)); + va_list mk; + va_start(mk, n); + return call_statement(stmt, gd, get_local_dict(cdu, frame, gd), n, mk); +} + +} + +BOOST_PYTHON_DECL object locals() +{ + handle<> frame(api_detail::get_current_frame()); + if(frame.get()) + return object(object(frame).attr("f_locals")); + else + return api::dict(); +} + + +BOOST_PYTHON_DECL object abs(object const& a0) { + return api_detail::get_func("abs")(a0); +} + +BOOST_PYTHON_DECL object abs(short a0) { + return api_detail::get_func("abs")(object(a0)); +} + +BOOST_PYTHON_DECL object abs(int a0) { + return api_detail::get_func("abs")(object(a0)); +} + +BOOST_PYTHON_DECL object abs(long a0) { + return api_detail::get_func("abs")(object(a0)); +} + +BOOST_PYTHON_DECL object abs(double const & a0) { + return api_detail::get_func("abs")(object(a0)); +} + +BOOST_PYTHON_DECL object apply(object const& a0, object const& a1) { + return object((python::detail::new_reference)::PyObject_CallObject(a0.ptr(), a1.ptr())); +} + +BOOST_PYTHON_DECL object apply(object const& a0, object const& a1, object const& a2) { + return object((python::detail::new_reference)::PyObject_Call(a0.ptr(), a1.ptr(), a2.ptr())); +} + +BOOST_PYTHON_DECL bool callable(object const& a0) { + return ::PyCallable_Check(a0.ptr()); +} + +BOOST_PYTHON_DECL object chr(object const& a0) { + return api_detail::get_func("chr")(a0); +} + +BOOST_PYTHON_DECL object chr(short a0) { + return api_detail::get_func("chr")(object(a0)); +} + +BOOST_PYTHON_DECL object chr(int a0) { + return api_detail::get_func("chr")(object(a0)); +} + +BOOST_PYTHON_DECL object chr(long a0) { + return api_detail::get_func("chr")(object(a0)); +} + +BOOST_PYTHON_DECL int cmp(object const& a0, object const& a1) { + int rslt; + int r = ::PyObject_Cmp(a0.ptr(), a1.ptr(), &rslt); + if(r == -1) + throw_error_already_set(); + return rslt; +} + +BOOST_PYTHON_DECL object coerce(object const& a0, object const& a1) { + return api_detail::get_func("coerce")(a0, a1); +} + +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("compile")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2) { + return api_detail::get_func("compile")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::get_func("compile")(a0, a1, a2, a3); +} + +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3) { + return api_detail::get_func("compile")(object(a0), object(a1), object(a2), object(a3)); +} + +BOOST_PYTHON_DECL object compile(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::get_func("compile")(a0, a1, a2, a3, a4); +} + +BOOST_PYTHON_DECL object compile(const char* a0, const char* a1, const char* a2, int a3, int a4) { + return api_detail::get_func("compile")(object(a0), object(a1), object(a2), object(a3), object(a4)); +} + +BOOST_PYTHON_DECL object complex(object const& a0) { + return api_detail::get_func("complex")(a0); +} + +BOOST_PYTHON_DECL object complex(double const& a0) { + return api_detail::get_func("complex")(object(a0)); +} + +BOOST_PYTHON_DECL object complex(object const& a0, object const& a1) { + return api_detail::get_func("complex")(a0, a1); +} + +BOOST_PYTHON_DECL object complex(double const& a0, double const& a1) { + return api_detail::get_func("complex")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object dict() { + return api_detail::get_func("dict")(); +} + +BOOST_PYTHON_DECL object dict(object const& a0) { + return api_detail::get_func("dict")(a0); +} + +BOOST_PYTHON_DECL object dir() { + return object((python::detail::new_reference)::PyObject_Dir(NULL)); +} + +BOOST_PYTHON_DECL object dir(object const& a0) { + return object((python::detail::new_reference)::PyObject_Dir(a0.ptr())); +} + +BOOST_PYTHON_DECL object divmod(object const& a0, object const& a1) { + return api_detail::get_func("divmod")(a0, a1); +} + +BOOST_PYTHON_DECL object divmod(int a0, int a1) { + return api_detail::get_func("divmod")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object divmod(long a0, long a1) { + return api_detail::get_func("divmod")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object divmod(double const& a0, double const& a1) { + return api_detail::get_func("divmod")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object eval(const char* a0) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_eval_input, globals().ptr(), globals().ptr())); +} + +BOOST_PYTHON_DECL object eval(const char* a0, object const& a2) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_eval_input, a2.ptr(), globals().ptr())); +} + +BOOST_PYTHON_DECL object eval(const char* a0, object const& a2, object const& a3) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_eval_input, a2.ptr(), a3.ptr())); +} + +BOOST_PYTHON_DECL object exec(const char* a0) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_file_input, globals().ptr(), globals().ptr())); +} + +BOOST_PYTHON_DECL object exec(const char* a0, object const& a2) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_file_input, a2.ptr(), globals().ptr())); +} + +BOOST_PYTHON_DECL object exec(const char* a0, object const& a2, object const& a3) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), Py_file_input, a2.ptr(), a3.ptr())); +} + +BOOST_PYTHON_DECL object execfile(object const& a0) { + return api_detail::get_func("execfile")(a0); +} + +BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1) { + return api_detail::get_func("execfile")(a0, a1); +} + +BOOST_PYTHON_DECL object execfile(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("execfile")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object file(object const& a0) { + return api_detail::get_func("file")(a0); +} + +BOOST_PYTHON_DECL object file(const char* a0) { + return api_detail::get_func("file")(object(a0)); +} + +BOOST_PYTHON_DECL object file(object const& a0, object const& a1) { + return api_detail::get_func("file")(a0, a1); +} + +BOOST_PYTHON_DECL object file(const char* a0, const char* a1) { + return api_detail::get_func("file")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object file(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("file")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object file(const char* a0, const char* a1, int a2) { + return api_detail::get_func("file")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object filter(object const& a0, object const& a1) { + return api_detail::get_func("filter")(a0, a1); +} + +BOOST_PYTHON_DECL object float_(object const& a0) { + return api_detail::get_func("float")(a0); +} + +BOOST_PYTHON_DECL object float_(const char* a0) { + return api_detail::get_func("float")(object(a0)); +} + +BOOST_PYTHON_DECL object float_(double const& a0) { + return api_detail::get_func("float")(object(a0)); +} + +BOOST_PYTHON_DECL object getattr(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("getattr")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object getattr(object const& a0, const char * a1, object const& a2) { + return api_detail::get_func("getattr")(a0, object(a1), a2); +} + +BOOST_PYTHON_DECL object globals() { + return object((python::detail::borrowed_reference)::PyModule_GetDict(PyImport_AddModule("__main__"))); +} + +BOOST_PYTHON_DECL bool hasattr(object const& a0, object const& a1) { + return ::PyObject_HasAttr(a0.ptr(), a1.ptr()); +} + +BOOST_PYTHON_DECL bool hasattr(object const& a0, const char* a1) { + return ::PyObject_HasAttrString(a0.ptr(), const_cast(a1)); +} + +BOOST_PYTHON_DECL long hash(object const& a0) { + long r = ::PyObject_Hash(a0.ptr()); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL object hex(object const& a0) { + return api_detail::get_func("hex")(a0); +} + +BOOST_PYTHON_DECL object hex(char a0) { + return api_detail::get_func("hex")(object(a0)); +} + +BOOST_PYTHON_DECL object hex(short a0) { + return api_detail::get_func("hex")(object(a0)); +} + +BOOST_PYTHON_DECL object hex(int a0) { + return api_detail::get_func("hex")(object(a0)); +} + +BOOST_PYTHON_DECL object hex(long a0) { + return api_detail::get_func("hex")(object(a0)); +} + +BOOST_PYTHON_DECL long id(object const& a0) { + object r(api_detail::get_func("id")(a0)); + return boost::python::arg_from_python(r.ptr())(r.ptr()); +} + +BOOST_PYTHON_DECL object input() { + return api_detail::get_func("input")(); +} + +BOOST_PYTHON_DECL object input(object const& a0) { + return api_detail::get_func("input")(a0); +} + +BOOST_PYTHON_DECL object input(const char* a0) { + return api_detail::get_func("input")(object(a0)); +} + +BOOST_PYTHON_DECL object int_(object const& a0) { + return api_detail::get_func("int")(a0); +} + +BOOST_PYTHON_DECL object int_(long a0) { + return api_detail::get_func("int")(object(a0)); +} + +BOOST_PYTHON_DECL object int_(const char* a0) { + return api_detail::get_func("int")(object(a0)); +} + +BOOST_PYTHON_DECL object intern(object const& a0) { + return api_detail::get_func("intern")(a0); +} + +BOOST_PYTHON_DECL object intern(const char* a0) { + return api_detail::get_func("intern")(object(a0)); +} + +BOOST_PYTHON_DECL bool isinstance(object const& a0, object const& a1) { + return ::PyObject_IsInstance(a0.ptr(), a1.ptr()); +} + +BOOST_PYTHON_DECL bool issubclass(object const& a0, object const& a1) { + return ::PyObject_IsSubclass(a0.ptr(), a1.ptr()); +} + +BOOST_PYTHON_DECL object iter(object const& a0) { + return object((python::detail::new_reference)::PyObject_GetIter(a0.ptr())); +} + +BOOST_PYTHON_DECL object iter(object const& a0, object const& a1) { + return api_detail::get_func("iter")(a0, a1); +} + +BOOST_PYTHON_DECL long len(object const& a0) { + long r = ::PyObject_Length(a0.ptr()); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL object list() { + return api_detail::get_func("list")(); +} + +BOOST_PYTHON_DECL object list(object const& a0) { + return api_detail::get_func("list")(a0); +} + +BOOST_PYTHON_DECL object long_(object const& a0) { + return api_detail::get_func("long")(a0); +} + +BOOST_PYTHON_DECL object long_(long a0) { + return api_detail::get_func("long")(object(a0)); +} + +BOOST_PYTHON_DECL object long_(const char* a0) { + return api_detail::get_func("long")(object(a0)); +} + +BOOST_PYTHON_DECL object map(object const& a0) { + return api_detail::get_func("map")(a0); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1) { + return api_detail::get_func("map")(a0, a1); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("map")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::get_func("map")(a0, a1, a2, a3); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4, a5); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4, a5, a6); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4, a5, a6, a7); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +BOOST_PYTHON_DECL object map(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::get_func("map")(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +BOOST_PYTHON_DECL object max(object const& a0) { + return api_detail::get_func("max")(a0); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1) { + return api_detail::get_func("max")(a0, a1); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("max")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::get_func("max")(a0, a1, a2, a3); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4, a5); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4, a5, a6); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4, a5, a6, a7); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +BOOST_PYTHON_DECL object max(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::get_func("max")(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +BOOST_PYTHON_DECL object min(object const& a0) { + return api_detail::get_func("min")(a0); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1) { + return api_detail::get_func("min")(a0, a1); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("min")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::get_func("min")(a0, a1, a2, a3); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4, a5); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4, a5, a6); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4, a5, a6, a7); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +BOOST_PYTHON_DECL object min(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::get_func("min")(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +BOOST_PYTHON_DECL object oct(object const& a0) { + return api_detail::get_func("oct")(a0); +} + +BOOST_PYTHON_DECL object oct(char a0) { + return api_detail::get_func("oct")(object(a0)); +} + +BOOST_PYTHON_DECL object oct(short a0) { + return api_detail::get_func("oct")(object(a0)); +} + +BOOST_PYTHON_DECL object oct(int a0) { + return api_detail::get_func("oct")(object(a0)); +} + +BOOST_PYTHON_DECL object oct(long a0) { + return api_detail::get_func("oct")(object(a0)); +} + +BOOST_PYTHON_DECL object open(object const& a0) { + return api_detail::get_func("open")(a0); +} + +BOOST_PYTHON_DECL object open(const char* a0) { + return api_detail::get_func("open")(object(a0)); +} + +BOOST_PYTHON_DECL object open(object const& a0, object const& a1) { + return api_detail::get_func("open")(a0, a1); +} + +BOOST_PYTHON_DECL object open(const char* a0, const char* a1) { + return api_detail::get_func("open")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object open(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("open")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object open(const char* a0, const char* a1, int a2) { + return api_detail::get_func("open")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL long ord(object const& a0) { + object r(api_detail::get_func("ord")(a0)); + return boost::python::arg_from_python(r.ptr())(r.ptr()); +} + +BOOST_PYTHON_DECL long ord(const char* a0) { + object r(api_detail::get_func("ord")(object(a0))); + return boost::python::arg_from_python(r.ptr())(r.ptr()); +} + +BOOST_PYTHON_DECL object pow(object const& a0, object const& a1) { + return api_detail::get_func("pow")(a0, a1); +} + +BOOST_PYTHON_DECL object pow(double const& a0, double const& a1) { + return api_detail::get_func("pow")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object pow(double const& a0, double const& a1, double const& a2) { + return api_detail::get_func("pow")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object print(object const& a0) { + return api_detail::call_statement_du("print _1", use_new_dict, 1, &a0); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1) { + return api_detail::call_statement_du("print _1, _2", use_new_dict, 2, &a0, &a1); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2) { + return api_detail::call_statement_du("print _1, _2, _3", use_new_dict, 3, &a0, &a1, &a2); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::call_statement_du("print _1, _2, _3, _4", use_new_dict, 4, &a0, &a1, &a2, &a3); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5", use_new_dict, 5, &a0, &a1, &a2, &a3, &a4); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6", use_new_dict, 6, &a0, &a1, &a2, &a3, &a4, &a5); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, &a0, &a1, &a2, &a3, &a4, &a5, &a6); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8); +} + +BOOST_PYTHON_DECL object print(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::call_statement_du("print _1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1) { + return api_detail::call_statement_du("print >>_1, _2", use_new_dict, 2, &a0, &a1); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2) { + return api_detail::call_statement_du("print >>_1, _2, _3", use_new_dict, 3, &a0, &a1, &a2); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4", use_new_dict, 4, &a0, &a1, &a2, &a3); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5", use_new_dict, 5, &a0, &a1, &a2, &a3, &a4); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6", use_new_dict, 6, &a0, &a1, &a2, &a3, &a4, &a5); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7", use_new_dict, 7, &a0, &a1, &a2, &a3, &a4, &a5, &a6); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8", use_new_dict, 8, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9", use_new_dict, 9, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10", use_new_dict, 10, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9); +} + +BOOST_PYTHON_DECL object print_file(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10) { + return api_detail::call_statement_du("print >>_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11", use_new_dict, 11, &a0, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10); +} + +BOOST_PYTHON_DECL object range(object const& a0) { + return api_detail::get_func("range")(a0); +} + +BOOST_PYTHON_DECL object range(int a0) { + return api_detail::get_func("range")(object(a0)); +} + +BOOST_PYTHON_DECL object range(object const& a0, object const& a1) { + return api_detail::get_func("range")(a0, a1); +} + +BOOST_PYTHON_DECL object range(int a0, int a1) { + return api_detail::get_func("range")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object range(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("range")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object range(int a0, int a1, int a2) { + return api_detail::get_func("range")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object raw_input() { + return api_detail::get_func("raw_input")(); +} + +BOOST_PYTHON_DECL object raw_input(object const& a0) { + return api_detail::get_func("raw_input")(a0); +} + +BOOST_PYTHON_DECL object raw_input(const char* a0) { + return api_detail::get_func("raw_input")(object(a0)); +} + +BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1) { + return api_detail::get_func("reduce")(a0, a1); +} + +BOOST_PYTHON_DECL object reduce(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("reduce")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object reload(object const& a0) { + return object((python::detail::new_reference)::PyImport_ReloadModule(a0.ptr())); +} + +BOOST_PYTHON_DECL object repr(object const& a0) { + return object((python::detail::new_reference)::PyObject_Repr(a0.ptr())); +} + +BOOST_PYTHON_DECL object round(object const& a0) { + return api_detail::get_func("round")(a0); +} + +BOOST_PYTHON_DECL object round(double const& a0) { + return api_detail::get_func("round")(object(a0)); +} + +BOOST_PYTHON_DECL object round(object const& a0, object const& a1) { + return api_detail::get_func("round")(a0, a1); +} + +BOOST_PYTHON_DECL object round(double const& a0, double const& a1) { + return api_detail::get_func("round")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object slice(object const& a0) { + return api_detail::get_func("slice")(a0); +} + +BOOST_PYTHON_DECL object slice(int a0) { + return api_detail::get_func("slice")(object(a0)); +} + +BOOST_PYTHON_DECL object slice(object const& a0, object const& a1) { + return api_detail::get_func("slice")(a0, a1); +} + +BOOST_PYTHON_DECL object slice(int a0, int a1) { + return api_detail::get_func("slice")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object slice(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("slice")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object slice(int a0, int a1, int a2) { + return api_detail::get_func("slice")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object str(object const& a0) { + return object((python::detail::new_reference)::PyObject_Str(a0.ptr())); +} + +BOOST_PYTHON_DECL object tuple() { + return api_detail::get_func("tuple")(); +} + +BOOST_PYTHON_DECL object tuple(object const& a0) { + return api_detail::get_func("tuple")(a0); +} + +BOOST_PYTHON_DECL object type_(object const& a0) { + return object((python::detail::new_reference)::PyObject_Type(a0.ptr())); +} + +BOOST_PYTHON_DECL object unichr(object const& a0) { + return api_detail::get_func("unichr")(a0); +} + +BOOST_PYTHON_DECL object unichr(short a0) { + return api_detail::get_func("unichr")(object(a0)); +} + +BOOST_PYTHON_DECL object unichr(int a0) { + return api_detail::get_func("unichr")(object(a0)); +} + +BOOST_PYTHON_DECL object unichr(long a0) { + return api_detail::get_func("unichr")(object(a0)); +} + +BOOST_PYTHON_DECL object unicode(object const& a0) { + return object((python::detail::new_reference)::PyObject_Unicode(a0.ptr())); +} + +BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1) { + return api_detail::get_func("unicode")(a0, a1); +} + +BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1) { + return api_detail::get_func("unicode")(a0, object(a1)); +} + +BOOST_PYTHON_DECL object unicode(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("unicode")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object unicode(object const& a0, const char* a1, const char* a2) { + return api_detail::get_func("unicode")(a0, object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object vars() { + return api_detail::get_func("vars")(); +} + +BOOST_PYTHON_DECL object vars(object const& a0) { + return api_detail::get_func("vars")(a0); +} + +BOOST_PYTHON_DECL object xrange(object const& a0) { + return api_detail::get_func("xrange")(a0); +} + +BOOST_PYTHON_DECL object xrange(int a0) { + return api_detail::get_func("xrange")(object(a0)); +} + +BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1) { + return api_detail::get_func("xrange")(a0, a1); +} + +BOOST_PYTHON_DECL object xrange(int a0, int a1) { + return api_detail::get_func("xrange")(object(a0), object(a1)); +} + +BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("xrange")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object xrange(int a0, int a1, int a2) { + return api_detail::get_func("xrange")(object(a0), object(a1), object(a2)); +} + +BOOST_PYTHON_DECL object zip(object const& a0) { + return api_detail::get_func("zip")(a0); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1) { + return api_detail::get_func("zip")(a0, a1); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2) { + return api_detail::get_func("zip")(a0, a1, a2); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3) { + return api_detail::get_func("zip")(a0, a1, a2, a3); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4, a5); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4, a5, a6); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4, a5, a6, a7); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4, a5, a6, a7, a8); +} + +BOOST_PYTHON_DECL object zip(object const& a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::get_func("zip")(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); +} + +BOOST_PYTHON_DECL object compile_string(const char* a0, const char* a1, int a2) { + return object((python::detail::new_reference)::Py_CompileString(const_cast(a0), const_cast(a1), a2)); +} + +BOOST_PYTHON_DECL int import_append_inittab(const char* a0, void(*a1)(void)) { + int r = ::PyImport_AppendInittab(const_cast(a0), a1); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL object import_add_module(const char* a0) { + return object((python::detail::borrowed_reference)::PyImport_AddModule(const_cast(a0))); +} + +BOOST_PYTHON_DECL object import_get_module_dict() { + return object((python::detail::borrowed_reference)::PyImport_GetModuleDict()); +} + +BOOST_PYTHON_DECL object import_import(object const& a0) { + return object((python::detail::new_reference)::PyImport_Import(a0.ptr())); +} + +BOOST_PYTHON_DECL object import_import(const char* a0) { + return object((python::detail::new_reference)::PyImport_Import(object(a0).ptr())); +} + +BOOST_PYTHON_DECL object import_import_module(const char* a0) { + return object((python::detail::new_reference)::PyImport_ImportModule(const_cast(a0))); +} + +BOOST_PYTHON_DECL object import_import_module_ex(const char* a0, object const& a1, object const& a2, object const& a3) { + return object((python::detail::new_reference)::PyImport_ImportModuleEx(const_cast(a0), a1.ptr(), a2.ptr(), a3.ptr())); +} + +BOOST_PYTHON_DECL object module_get_dict(object const& a0) { + return object((python::detail::borrowed_reference)::PyModule_GetDict(a0.ptr())); +} + +BOOST_PYTHON_DECL int object_print(object const& a0, FILE* a1, int a2) { + int r = ::PyObject_Print(a0.ptr(), a1, a2); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL object run_file(FILE* a0, const char* a1, int a2, object const& a3, object const& a4) { + return object((python::detail::new_reference)::PyRun_File(a0, const_cast(a1), a2, a3.ptr(), a4.ptr())); +} + +BOOST_PYTHON_DECL int run_simple_file(FILE* a0, const char* a1) { + int r = ::PyRun_SimpleFile(a0, const_cast(a1)); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL int run_simple_string(const char* a0) { + int r = ::PyRun_SimpleString(const_cast(a0)); + if(r == -1) + throw_error_already_set(); + return r; +} + +BOOST_PYTHON_DECL object run_string(const char* a0, int a1, object const& a2, object const& a3) { + return object((python::detail::new_reference)::PyRun_String(const_cast(a0), a1, a2.ptr(), a3.ptr())); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0) { + return api_detail::call_statement(a0); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1) { + return api_detail::call_statement_du(a0, a1); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1) { + return api_detail::call_statement(a0, 1, &a1); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2) { + return api_detail::call_statement(a0, 2, &a1, &a2); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3) { + return api_detail::call_statement(a0, 3, &a1, &a2, &a3); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4) { + return api_detail::call_statement(a0, 4, &a1, &a2, &a3, &a4); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::call_statement(a0, 5, &a1, &a2, &a3, &a4, &a5); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::call_statement(a0, 6, &a1, &a2, &a3, &a4, &a5, &a6); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::call_statement(a0, 7, &a1, &a2, &a3, &a4, &a5, &a6, &a7); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::call_statement(a0, 8, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::call_statement(a0, 9, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, object const& a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10) { + return api_detail::call_statement(a0, 10, &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2) { + return api_detail::call_statement_du(a0, a1, 1, &a2); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3) { + return api_detail::call_statement_du(a0, a1, 2, &a2, &a3); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4) { + return api_detail::call_statement_du(a0, a1, 3, &a2, &a3, &a4); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5) { + return api_detail::call_statement_du(a0, a1, 4, &a2, &a3, &a4, &a5); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6) { + return api_detail::call_statement_du(a0, a1, 5, &a2, &a3, &a4, &a5, &a6); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7) { + return api_detail::call_statement_du(a0, a1, 6, &a2, &a3, &a4, &a5, &a6, &a7); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8) { + return api_detail::call_statement_du(a0, a1, 7, &a2, &a3, &a4, &a5, &a6, &a7, &a8); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9) { + return api_detail::call_statement_du(a0, a1, 8, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10) { + return api_detail::call_statement_du(a0, a1, 9, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10); +} + +BOOST_PYTHON_DECL object call_statement(const char* a0, call_dict_usage a1, object const& a2, object const& a3, object const& a4, object const& a5, object const& a6, object const& a7, object const& a8, object const& a9, object const& a10, object const& a11) { + return api_detail::call_statement_du(a0, a1, 10, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9, &a10, &a11); +} + + +}}} + diff --git a/test/Jamfile b/test/Jamfile index 77ff5c7c..0bde874d 100644 --- a/test/Jamfile +++ b/test/Jamfile @@ -93,6 +93,7 @@ run bases.cpp ; run if_else.cpp ; run pointee.cpp ; run result.cpp ; +run submod_subclass_api.cpp ../bpl : : : $(PYTHON_PROPERTIES) ; compile string_literal.cpp ; compile borrowed.cpp : $(UNIT_TEST_PROPERTIES) ; compile object_manager.cpp : $(UNIT_TEST_PROPERTIES) ; diff --git a/test/submod_subclass_api.cpp b/test/submod_subclass_api.cpp new file mode 100644 index 00000000..b2c5293e --- /dev/null +++ b/test/submod_subclass_api.cpp @@ -0,0 +1,231 @@ +// Copyright David Hawkes 2002. +// Permission is hereby granted to copy, use and modify this software +// for any purpose, including commercial distribution, provided this +// copyright notice is not removed. No warranty WHATSOEVER is provided with this +// software. Any user(s) accepts this software "as is" and as such they will not +// bind the author(s) to any claim of suitabilty for any purpose. + +// embed_test.cpp : substantial test of embedding python in c++ using boost + +#include +#include +#include +#include +#include +#include +#include +#include + +using namespace boost; +using namespace boost::python; + + +// The following macros are for our convenience and coding expediency... +// There is no particular recomendation that they be used elsewhere +// as they are not feature complete and are just sufficient to suport +// the code here + + +#define DEF(fn) def(#fn, fn) +#define DEF_C(c, fn) def(#fn, &c::fn) +#define DEF_C_CB(c, fn) def(#fn, &c##_callback::base_##fn) + +#define CLASS(c) class_ >(#c) +#define CLASS_CB(c) class_, noncopyable >(#c) + +#define START_CALLBACK_CLASS(c) \ +class c##_callback : public c \ +{ \ + typedef c __base__; \ +public: \ + c##_callback(PyObject* self) : m_self(self) {} \ +private: \ + PyObject* m_self; \ +public: + +#define END_CALLBACK_CLASS }; + + +#define CALLBACK_MEMBER0(fn, rtn) \ +rtn fn() { return call_method(m_self, #fn); } \ +rtn base_##fn() { return __base__::fn(); } + + +#define CALLBACK_MEMBER0C(fn, rtn) \ +rtn fn() const { return call_method(m_self, #fn); } \ +rtn base_##fn() const { return __base__::fn(); } +// End of convenience macros + +// useful support classes +template +struct class_object : public object +{ + typedef object base; + class_object() : m_class_ptr(NULL) {} + class_object(object const& o) : base(o) { init(); } + class_object& operator=(object const& o) + { + base::operator=(o); + init(); + return *this; + } + T* operator->() const { return m_class_ptr; } + T& operator*() const { return *m_class_ptr; } +private: + void init() + { + m_class_ptr = arg_from_python(ptr())(ptr()); + } + T* m_class_ptr; +}; + +template +struct item_object : public object +{ + typedef object base; + item_object() {} + item_object(object const& o) : base(o), m_class(arg_from_python(ptr())(ptr())) {} + item_object& operator=(object const& o) + { + base::operator=(o); + init(); + return *this; + } + operator T() { return m_class; } +private: + void init() + { + m_class = arg_from_python(ptr())(ptr()); + } + T m_class; +}; +// end of useful support classes + +// pass our args in this struct +struct main_args { + main_args(int _argc, char* _argv[]) : argc(_argc), argv(_argv) {} + int argc; + char** argv; +}; +int python_main(main_args const &ma); + +// python module init +BOOST_PYTHON_MODULE_INIT(python_main) +{ + DEF(python_main); + CLASS(main_args); +} + +// sub module tests +namespace sm { + +int test_func() { return 7; } + +BOOST_PYTHON_MODULE_INIT(sm_test) +{ + // define a submodule + boost::python::module(".sm"); + // define a 2nd submodule + boost::python::module(".sm.sm2"); + // define a test function to appear in 2nd submodule + DEF(test_func); +} + +// sub-module tests +int test() +{ + api::run_simple_string("import sm_test"); + if(api::call_statement("_0 = bpl_test('sub modules', sm_test.sm.sm2.test_func, _1)", test_func())) + return 1; + return 0; +} + +} + +// sub class tests +namespace sc { + +class c1 { +public: + c1() {} + class c2 { + public: + c2() : n(2) {} + int n; + }; + c2 t; +}; + +c1::c2 test_func() { + return c1().t; +} + +BOOST_PYTHON_MODULE_INIT(sc_test) +{ + class_("c1.c2") + .def_init() + .def_readwrite("n", &c1::c2::n); + CLASS(c1) + .def_init() + .def_readwrite("t", &c1::t); + DEF(test_func); +} + +// sub-class tests +int test() +{ + api::run_simple_string("import sc_test"); + if(api::call_statement("_0 = bpl_test('sub classes', lambda : sc_test.c1.c2().n, _1.n)", test_func())) + return 1; + if(api::call_statement("_0 = bpl_test('sub classes', lambda : sc_test.c1().t.n, _1.n)", test_func())) + return 1; + return 0; +} + +} + +// new main that will have a python execution frame +int main(int argc, char* argv[]) +{ + // default return value; + int rtn = 0; + // define all the built-in modules used + PyImport_AppendInittab("python_main", initpython_main); + PyImport_AppendInittab("sm_test", sm::initsm_test); + PyImport_AppendInittab("sc_test", sc::initsc_test); + // initialize python + Py_Initialize(); + // start a new block so that any objects are released prior to finalizing + { + // import our main module - this will also initialise boost + api::run_simple_string("import python_main"); + // We call back here so we have a proper python execution frame to work with + item_object o_rtn(api::call_statement("_0 = python_main.python_main(_1)", main_args(argc, argv))); + rtn = o_rtn; + } + // clean up + Py_Finalize(); + return rtn; +} + +char *bpl_test = +"def bpl_test(name, func, result):\n" +" print 'testing %s...' % name\n" +" if func() != result:\n" +" print 'failed'\n" +" return 1\n" +" else:\n" +" print 'OK'\n" +" return 0\n"; + + +int python_main(main_args const &ma) +{ + api::print("running...\n"); + api::call_statement(bpl_test); + if(sm::test()) + return 1; + if(sc::test()) + return 1; + return 0; +}