boost/python
2
0
Fork 0
mirror of https://github.com/boostorg/python.git synced 2026-01-20 16:52:15 +00:00
Code Issues Projects Releases Wiki Activity

Sub-module / sub-class and API changes

Browse Source 
[SVN r14488]
This commit is contained in:
David Hawkes
2002-07-17 06:51:08 +00:00
parent 244e0fa5e6
commit 61ba4cd1ce
15 changed files with 3204 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Jamfile
View File

@@ -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

38
include/boost/python/class.hpp
View File

@@ -14,6 +14,7 @@
# include <boost/python/type_id.hpp>
# include <boost/python/detail/wrap_function.hpp>
# include <boost/python/detail/member_function_cast.hpp>
# include <boost/python/detail/module_base.hpp>
# include <boost/python/object/class_converters.hpp>
# include <boost/type_traits/ice.hpp>
# include <boost/type_traits/same_traits.hpp>
@@ -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 <class T, class X1, class X2, class X3>
inline class_<T,X1,X2,X3>::class_()
inline class_<T,X1,X2,X3>::class_(base const& parent_class)
: base(typeid(T).name(), id_vector::size, id_vector().ids)
{
// register converters
@@ -241,10 +258,16 @@ inline class_<T,X1,X2,X3>::class_()
mpl::bool_t<is_copyable>()
, objects::select_holder<T,held_type>((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 <class T, class X1, class X2, class X3>
inline class_<T,X1,X2,X3>::class_(char const* name)
inline class_<T,X1,X2,X3>::class_(char const* name, base const& parent_class)
: base(name, id_vector::size, id_vector().ids)
{
// register converters
@@ -254,8 +277,13 @@ inline class_<T,X1,X2,X3>::class_(char const* name)
mpl::bool_t<is_copyable>()
, objects::select_holder<T,held_type>((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 <class T, class X1, class X2, class X3>
inline class_<T,X1,X2,X3>& class_<T,X1,X2,X3>::add_property(char const* name, handle<> const& fget)

16
include/boost/python/detail/module_base.hpp
View File

@@ -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

51
include/boost/python/detail/module_info.hpp Normal file
View File

@@ -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 <boost/python/object.hpp>
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

18
include/boost/python/detail/module_init.hpp
View File

@@ -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 <boost/python/detail/aix_init_module.hpp>
# 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()

27
include/boost/python/module.hpp
View File

@@ -13,6 +13,7 @@
# include <boost/python/class_fwd.hpp>
# include <boost/python/detail/module_base.hpp>
# include <boost/python/detail/module_init.hpp>
# include <boost/python/detail/module_info.hpp>
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 <class T1, class T2 , class T3, class T4>
module& add(class_<T1,T2,T3,T4> 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 <class Fn>
inline void def(char const* name, Fn fn)
{
module::get_prior_module().def(name, fn);
}
template <class Fn, class ResultHandler>
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

5
include/boost/python/object/class.hpp
View File

@@ -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;
};

1
include/boost/python/object_core.hpp
View File

@@ -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))
{}

700
include/boost/python/py_interface.hpp Normal file
View File

@@ -0,0 +1,700 @@
// Automatically generated from py_api_gen.py
#ifndef PY_INTERFACE_HPP
#define PY_INTERFACE_HPP
#include <boost/python/object.hpp>
#include <boost/python/arg_from_python.hpp>
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<class A>
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<object>
{
get_arg(object const &a) : h(a) {}
object const &h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<PyObject*>
{
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<class A0>
object abs(A0 const& a0)
{
return api_detail::get_func("abs")(api_detail::get_arg<A0>(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<class A0>
object chr(A0 const& a0)
{
return api_detail::get_func("chr")(api_detail::get_arg<A0>(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<class A0, class A1>
int cmp(A0 const& a0, A1 const& a1)
{
int rslt;
int r = ::PyObject_Cmp(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(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<class A0>
object complex(A0 const& a0)
{
return api_detail::get_func("complex")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object complex(object const& a0);
BOOST_PYTHON_DECL object complex(double const& a0);
template<class A0, class A1>
object complex(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("complex")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(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<class A0, class A1>
object divmod(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("divmod")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(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<class A0>
object hex(A0 const& a0)
{
return api_detail::get_func("hex")(api_detail::get_arg<A0>(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<class A0>
object max(A0 const& a0)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
object max(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
object max(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("max")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8), api_detail::get_arg<A9>(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<class A0>
object min(A0 const& a0)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
object min(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
object min(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("min")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(a2), api_detail::get_arg<A3>(a3), api_detail::get_arg<A4>(a4), api_detail::get_arg<A5>(a5), api_detail::get_arg<A6>(a6), api_detail::get_arg<A7>(a7), api_detail::get_arg<A8>(a8), api_detail::get_arg<A9>(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<class A0>
object oct(A0 const& a0)
{
return api_detail::get_func("oct")(api_detail::get_arg<A0>(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<class A0, class A1>
object pow(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("pow")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(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<class A0>
object print(A0 const& a0)
{
return api_detail::call_statement_du("print _1", use_new_dict, 1, (object const*)api_detail::get_arg<A0>(a0));
}
template<class A0, class A1>
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>(a0), (object const*)api_detail::get_arg<A1>(a1));
}
template<class A0, class A1, class A2>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A0, class A1, class A2, class A3>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A0, class A1, class A2, class A3, class A4>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A0, class A1, class A2, class A3, class A4, class A5>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A0, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a0), (object const*)api_detail::get_arg<A1>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(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<class A1>
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>(a1));
}
template<class A1, class A2>
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>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A1, class A2, class A3>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A1, class A2, class A3, class A4>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A1, class A2, class A3, class A4, class A5>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A1, class A2, class A3, class A4, class A5, class A6>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(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<class A0>
object range(A0 const& a0)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object range(object const& a0);
BOOST_PYTHON_DECL object range(int a0);
template<class A0, class A1>
object range(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object range(object const& a0, object const& a1);
BOOST_PYTHON_DECL object range(int a0, int a1);
template<class A0, class A1, class A2>
object range(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("range")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(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<class A0>
object round(A0 const& a0)
{
return api_detail::get_func("round")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object round(object const& a0);
BOOST_PYTHON_DECL object round(double const& a0);
template<class A0, class A1>
object round(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("round")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object round(object const& a0, object const& a1);
BOOST_PYTHON_DECL object round(double const& a0, double const& a1);
template<class A0>
object slice(A0 const& a0)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object slice(object const& a0);
BOOST_PYTHON_DECL object slice(int a0);
template<class A0, class A1>
object slice(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object slice(object const& a0, object const& a1);
BOOST_PYTHON_DECL object slice(int a0, int a1);
template<class A0, class A1, class A2>
object slice(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("slice")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(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<class A0>
object unichr(A0 const& a0)
{
return api_detail::get_func("unichr")(api_detail::get_arg<A0>(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<class A0>
object xrange(A0 const& a0)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0));
}
BOOST_PYTHON_DECL object xrange(object const& a0);
BOOST_PYTHON_DECL object xrange(int a0);
template<class A0, class A1>
object xrange(A0 const& a0, A1 const& a1)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1));
}
BOOST_PYTHON_DECL object xrange(object const& a0, object const& a1);
BOOST_PYTHON_DECL object xrange(int a0, int a1);
template<class A0, class A1, class A2>
object xrange(A0 const& a0, A1 const& a1, A2 const& a2)
{
return api_detail::get_func("xrange")(api_detail::get_arg<A0>(a0), api_detail::get_arg<A1>(a1), api_detail::get_arg<A2>(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<class A1>
object call_statement(const char* a0, A1 const& a1)
{
return api_detail::call_statement(a0, 1, (object const*)api_detail::get_arg<A1>(a1));
}
template<class A1, class A2>
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>(a1), (object const*)api_detail::get_arg<A2>(a2));
}
template<class A1, class A2, class A3>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A1, class A2, class A3, class A4>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A1, class A2, class A3, class A4, class A5>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A1, class A2, class A3, class A4, class A5, class A6>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
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>(a1), (object const*)api_detail::get_arg<A2>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(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<class A2>
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>(a2));
}
template<class A2, class A3>
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>(a2), (object const*)api_detail::get_arg<A3>(a3));
}
template<class A2, class A3, class A4>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4));
}
template<class A2, class A3, class A4, class A5>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5));
}
template<class A2, class A3, class A4, class A5, class A6>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6));
}
template<class A2, class A3, class A4, class A5, class A6, class A7>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10));
}
template<class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9, class A10, class A11>
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>(a2), (object const*)api_detail::get_arg<A3>(a3), (object const*)api_detail::get_arg<A4>(a4), (object const*)api_detail::get_arg<A5>(a5), (object const*)api_detail::get_arg<A6>(a6), (object const*)api_detail::get_arg<A7>(a7), (object const*)api_detail::get_arg<A8>(a8), (object const*)api_detail::get_arg<A9>(a9), (object const*)api_detail::get_arg<A10>(a10), (object const*)api_detail::get_arg<A11>(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

776
src/gen_py_api.py Normal file
View File

@@ -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 <boost/python/object.hpp>
#include <boost/python/arg_from_python.hpp>
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<class A>
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<object>
{
get_arg(object const &a) : h(a) {}
object const &h;
operator object const& () { return h; }
operator object const* () { return &h; }
};
template<>
struct get_arg<PyObject*>
{
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 <boost/python/py_interface.hpp>
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<char *>("__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<aname>[^\s=]+)\s*(=\s*(?P<qt>"?)(?P<aval>.+)(?P=qt))?', val).groupdict()
vals_dict[m['aname']] = m['aval']
return vals_dict
def SplitOutAttrs(a):
soa = {}
m = re.match(r'(?P<name>[^{]+)({(?P<attrs>[^}]+)})?', 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>(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>(a%s)' % (sn, sn)
else:
return 'api_detail::get_arg<A%s>(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<rtn>\S+)\s+(?P<fname>[^\s\(\){}]+({[^{}]*})?)\s*\((?P<args>(({[^{}]*})+|(\([^\(\)]*\))+|[^\(\)]+)*)\)', 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()

139
src/module.cpp
View File

@@ -7,16 +7,107 @@
// producing this work.
#include <boost/python/detail/module_base.hpp>
#include <boost/python/detail/module_init.hpp>
#include <boost/python/detail/module_info.hpp>
#include <boost/python/object/function.hpp>
#include <boost/python/object/class.hpp>
#include <boost/python/cast.hpp>
namespace boost { namespace python { namespace detail {
module_base::module_base(const char* name)
: m_module(
python::borrowed(Py_InitModule(const_cast<char*>(name), initial_methods))
)
namespace {
object getattr_or_none(object const &obj, const char *name)
{
if(PyObject_HasAttrString(obj.ptr(), const_cast<char*>(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<char*>(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<char*>(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<PyObject>(class_obj.get())
, const_cast<char*>("__module__"), module_name.get());
handle<>(class_obj).get(), const_cast<char*>("__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

117
src/object/class.cpp
View File

@@ -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 <boost/python/detail/module_base.hpp>
#include <boost/python/converter/registry.hpp>
#include <boost/python/object/class.hpp>
#include <boost/python/object/find_instance.hpp>
#include <boost/python/detail/map_entry.hpp>
#include <boost/python/detail/module_info.hpp>
#include <boost/python/class.hpp>
#include <boost/python/object.hpp>
#include <boost/detail/binary_search.hpp>
#include <boost/python/self.hpp>
@@ -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<PyObject>(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<char*>(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<empty_class>());
// 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_<empty_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

1103
src/py_interface.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

1
test/Jamfile
View File

@@ -93,6 +93,7 @@ run bases.cpp ;
run if_else.cpp ;
run pointee.cpp ;
run result.cpp ;
run submod_subclass_api.cpp <dll>../bpl : : : $(PYTHON_PROPERTIES) ;
compile string_literal.cpp ;
compile borrowed.cpp : $(UNIT_TEST_PROPERTIES) ;
compile object_manager.cpp : $(UNIT_TEST_PROPERTIES) ;

231
test/submod_subclass_api.cpp Normal file
View File

@@ -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 <boost/python/module.hpp>
#include <boost/python/class.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/call.hpp>
#include <boost/python/object.hpp>
#include <boost/python/py_interface.hpp>
#include <boost/utility.hpp>
#include <boost/shared_ptr.hpp>
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, shared_ptr<c> >(#c)
#define CLASS_CB(c) class_<c, shared_ptr<c##_callback>, 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<rtn>(m_self, #fn); } \
rtn base_##fn() { return __base__::fn(); }
#define CALLBACK_MEMBER0C(fn, rtn) \
rtn fn() const { return call_method<rtn>(m_self, #fn); } \
rtn base_##fn() const { return __base__::fn(); }
// End of convenience macros
// useful support classes
template<class T>
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<T*>(ptr())(ptr());
}
T* m_class_ptr;
};
template<class T>
struct item_object : public object
{
typedef object base;
item_object() {}
item_object(object const& o) : base(o), m_class(arg_from_python<T>(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<T>(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>("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<int> 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;
}