From 8e74a5902a45eecf06452b26eb66e53575af0d40 Mon Sep 17 00:00:00 2001 From: nobody Date: Wed, 18 Oct 2000 16:09:58 +0000 Subject: [PATCH] This commit was manufactured by cvs2svn to create branch 'to_python_experiments'. [SVN r8004] --- class_wrapper.h | 39 ++++ comparisons.html | 5 +- extclass.cpp | 62 +++++- extclass.h | 181 ++++++++++++++- extclass_demo.cpp | 313 ++++++++++++++++++++++++++ gcc.mak | 12 +- newtypes.cpp | 522 +++++++++++++++++++++++++++++++------------- newtypes.h | 37 +++- objects.h | 26 ++- py.cpp | 23 +- py.h | 5 + py_cpp.html | 6 +- py_cpp_20001013.zip | Bin 104507 -> 0 bytes subclass.cpp | 160 +++++++++++++- subclass.h | 190 +++++++++++++++- test_extclass.py | 158 +++++++++++++- todo.txt | 6 +- vc6_prj/vc6_prj.opt | Bin 0 -> 66048 bytes 18 files changed, 1554 insertions(+), 191 deletions(-) delete mode 100644 py_cpp_20001013.zip create mode 100644 vc6_prj/vc6_prj.opt diff --git a/class_wrapper.h b/class_wrapper.h index dbb64e4a..b383d263 100644 --- a/class_wrapper.h +++ b/class_wrapper.h @@ -65,6 +65,45 @@ class ClassWrapper template void def_read_write(MemberType T::*pm, const char* name) { m_class->def_read_write(pm, name); } + + // declare the given class a base class of this one and register + // conversion functions + template + void declare_base(ClassWrapper const & base) + { + m_class->declare_base(base.get_extension_class()); + } + + // declare the given class a base class of this one and register + // upcast conversion function + template + void declare_base(ClassWrapper const & base, WithoutDowncast) + { + m_class->declare_base(base.get_extension_class(), without_downcast); + } + + // declare the given class a base class of this one and register + // conversion functions + template + void declare_base(ExtensionClass * base) + { + m_class->declare_base(base); + } + + // declare the given class a base class of this one and register + // upcast conversion function + template + void declare_base(ExtensionClass * base, WithoutDowncast) + { + m_class->declare_base(base, without_downcast); + } + + // get the embedded ExtensioClass object + ExtensionClass * get_extension_class() const + { + return m_class.get(); + } + private: PyPtr > m_class; }; diff --git a/comparisons.html b/comparisons.html index 565e8bad..d2cabc62 100644 --- a/comparisons.html +++ b/comparisons.html @@ -149,9 +149,8 @@ Acquisition.
  • Zope's ComputedAttribute support is designed to be used from Python. - The analogous feature of py_cp is designed to be used from C++ (I - make no claims that the py_cpp mechanism is more useful than the Zope - mechanism in this case) + The analogous feature of py_cpp can be used from C++ or Python. The + feature is arguably easier to use in py_cpp.

    Also, the Zope docs say: "The first superclass listed in the class diff --git a/extclass.cpp b/extclass.cpp index a1734760..c654afa3 100644 --- a/extclass.cpp +++ b/extclass.cpp @@ -157,7 +157,7 @@ void report_missing_instance_data( } else { - two_string_error(PyExc_TypeError, "extension class '%.*s' is not derived from '%.*s'.", + two_string_error(PyExc_TypeError, "extension class '%.*s' is not convertible into '%.*s'.", instance->ob_type->tp_name, target_class->tp_name); } } @@ -218,6 +218,66 @@ ExtensionClassBase::ExtensionClassBase(const char* name) { } +// This function is used in from_python() to convert wrapped classes that are +// related by inheritance. The problem is this: although C++ provides all necessary +// conversion operators, source and target of a conversion must be known at compile +// time. However, in Python we want to convert classes at runtime. The solution is to +// generate conversion functions at compile time, register them within the appropriate +// class objects and call them when a particular runtime conversion is required. + +// If functions for any possible conversion have to be stored, their number will grow +// qudratically. To reduce this number, we actually store only conversion functions +// between adjacent levels in the inheritance tree. By traversing the tree recursively, +// we can build any allowed conversion as a concatenation of simple conversions. This +// traversal is done in the functions try_base_class_conversions() and +// try_derived_class_conversions(). If a particular conversion is impossible, all +// conversion functions will return a NULL pointer. + +// The function extract_object_from_holder() attempts to actually extract the pointer +// to the contained object from an InstanceHolderBase (a wrapper class). A conversion +// of the held object to 'T *' is allowed when the conversion +// 'dynamic_cast *>(an_instance_holder_base)' succeeds. +void* ExtensionClassBase::try_class_conversions(InstanceHolderBase* object) const +{ + void* result = try_derived_class_conversions(object); + if(result) + return result; + + return try_base_class_conversions(object); +} + +void* ExtensionClassBase::try_base_class_conversions(InstanceHolderBase* object) const +{ + for (std::size_t i = 0; i < base_classes().size(); ++i) + { + if(base_classes()[i].convert == 0) + continue; + void* result1 = base_classes()[i].class_object->extract_object_from_holder(object); + if (result1) + return (*base_classes()[i].convert)(result1); + + void* result2 = base_classes()[i].class_object->try_base_class_conversions(object); + if (result2) + return (*base_classes()[i].convert)(result2); + } + return 0; +} + +void* ExtensionClassBase::try_derived_class_conversions(InstanceHolderBase* object) const +{ + for (std::size_t i = 0; i < derived_classes().size(); ++i) + { + void* result1 = derived_classes()[i].class_object->extract_object_from_holder(object); + if (result1) + return (*derived_classes()[i].convert)(result1); + + void* result2 = derived_classes()[i].class_object->try_derived_class_conversions(object); + if (result2) + return (*derived_classes()[i].convert)(result2); + } + return 0; +} + void ExtensionClassBase::add_method(Function* method, const char* name) { add_method(PyPtr(method), name); diff --git a/extclass.h b/extclass.h index 3374c0ae..9b5ff64b 100644 --- a/extclass.h +++ b/extclass.h @@ -27,6 +27,7 @@ namespace py { // forward declarations class ExtensionInstance; +class ExtensionClassBase; template class InstanceHolder; template class InstanceValueHolder; template class InstancePtrHolder; @@ -53,10 +54,39 @@ T* check_non_null(T* p) template class HeldInstance; +namespace detail { + typedef void* (*ConversionFunction)(void*); + + struct BaseClassInfo + { + BaseClassInfo(ExtensionClassBase* t, ConversionFunction f) + :class_object(t), convert(f) + {} + + ExtensionClassBase* class_object; + ConversionFunction convert; + }; + + typedef BaseClassInfo DerivedClassInfo; +} + class ExtensionClassBase : public Class { public: ExtensionClassBase(const char* name); + + public: + // the purpose of try_class_conversions() and its related functions + // is explained in extclass.cpp + void* try_class_conversions(InstanceHolderBase*) const; + void* try_base_class_conversions(InstanceHolderBase*) const; + void* try_derived_class_conversions(InstanceHolderBase*) const; + + private: + virtual void* extract_object_from_holder(InstanceHolderBase* v) const = 0; + virtual std::vector const& base_classes() const = 0; + virtual std::vector const& derived_classes() const = 0; + protected: void add_method(PyPtr method, const char* name); void add_default_method(PyPtr method, const char* name); @@ -72,12 +102,24 @@ template class ClassRegistry { public: - static Class* class_object() + static ExtensionClassBase* class_object() { return static_class_object; } - static void register_class(py::Class*); - static void unregister_class(py::Class*); + + // Register/unregister the Python class object corresponding to T + static void register_class(ExtensionClassBase*); + static void unregister_class(ExtensionClassBase*); + + // Establish C++ inheritance relationships + static void register_base_class(py::detail::BaseClassInfo const&); + static void register_derived_class(py::detail::DerivedClassInfo const&); + + // Query the C++ inheritance relationships + static std::vector const& base_classes(); + static std::vector const& derived_classes(); private: - static py::Class* static_class_object; + static ExtensionClassBase* static_class_object; + static std::vector static_base_class_info; + static std::vector static_derived_class_info; }; #ifdef PY_NO_INLINE_FRIENDS_IN_NAMESPACE // back to global namespace for this GCC bug @@ -123,6 +165,11 @@ class PyExtensionClassConverters py::InstanceHolder* held = dynamic_cast*>(*p); if (held != 0) return held->target(); + + // see extclass.cpp for an explanation of try_class_conversions() + void * target = py::ClassRegistry::class_object()->try_class_conversions(*p); + if(target) + return static_cast(target); } py::report_missing_instance_data(self, py::ClassRegistry::class_object(), typeid(T)); throw py::ArgumentError(); @@ -171,7 +218,6 @@ class PyExtensionClassConverters return py::PyPtr(new py::ExtensionInstance(class_)); } - // Convert to const T* friend const T* from_python(PyObject* p, py::Type) { return from_python(p, py::Type()); } @@ -250,6 +296,28 @@ class ReadOnlySetattrFunction : public Function String m_name; }; +namespace detail +{ + +template +struct DefineConversion +{ + static void * upcast_ptr(void * v) + { + return static_cast(static_cast(v)); + } + + static void * downcast_ptr(void * v) + { + return dynamic_cast(static_cast(v)); + } +}; + +} + +enum WithoutDowncast { without_downcast }; + + // An easy way to make an extension base class which wraps T. Note that Python // subclasses of this class will simply be Class objects. // @@ -344,10 +412,49 @@ class ExtensionClass this->def_getter(pm, name); this->def_setter(pm, name); } + + // declare the given class a base class of this one and register + // up and down conversion functions + template + void declare_base(ExtensionClass * base) + { + // see extclass.cpp for an explanation of why we need to register + // conversion functions + detail::BaseClassInfo baseInfo(base, + &detail::DefineConversion::downcast_ptr); + ClassRegistry::register_base_class(baseInfo); + add_base(Ptr(as_object(base), Ptr::new_ref)); + + detail::DerivedClassInfo derivedInfo(this, + &detail::DefineConversion::upcast_ptr); + ClassRegistry::register_derived_class(derivedInfo); + } + + // declare the given class a base class of this one and register + // only up conversion function + template + void declare_base(ExtensionClass * base, WithoutDowncast) + { + // see extclass.cpp for an explanation of why we need to register + // conversion functions + detail::BaseClassInfo baseInfo(base, 0); + ClassRegistry::register_base_class(baseInfo); + add_base(Ptr(as_object(base), Ptr::new_ref)); + + detail::DerivedClassInfo derivedInfo(this, + &detail::DefineConversion::upcast_ptr); + ClassRegistry::register_derived_class(derivedInfo); + } - private: + private: // types typedef InstanceValueHolder Holder; - + + private: // ExtensionClassBase virtual function implementations + std::vector const& base_classes() const; + std::vector const& derived_classes() const; + void* extract_object_from_holder(InstanceHolderBase* v) const; + + private: // Utility functions template void add_constructor(Signature sig) { @@ -425,7 +532,7 @@ class InstancePtrHolder : public InstanceHolder public: HeldType* target() { return &*m_ptr; } PtrType& ptr() { return m_ptr; } - + InstancePtrHolder(PtrType ptr) : m_ptr(ptr) {} private: PtrType m_ptr; @@ -464,6 +571,30 @@ ExtensionClass::ExtensionClass(const char* name) ClassRegistry::register_class(this); } +template +inline +std::vector const & +ExtensionClass::base_classes() const +{ + return ClassRegistry::base_classes(); +} + +template +inline +std::vector const & +ExtensionClass::derived_classes() const +{ + return ClassRegistry::derived_classes(); +} + +template +void* ExtensionClass::extract_object_from_holder(InstanceHolderBase* v) const +{ + py::InstanceHolder* held = dynamic_cast*>(v); + if(held) return held->target(); + return 0; +} + template ExtensionClass::~ExtensionClass() { @@ -471,7 +602,7 @@ ExtensionClass::~ExtensionClass() } template -inline void ClassRegistry::register_class(Class* p) +inline void ClassRegistry::register_class(ExtensionClassBase* p) { // You're not expected to create more than one of these! assert(static_class_object == 0); @@ -479,7 +610,7 @@ inline void ClassRegistry::register_class(Class* p) } template -inline void ClassRegistry::unregister_class(Class* p) +inline void ClassRegistry::unregister_class(ExtensionClassBase* p) { // The user should be destroying the same object they created. assert(static_class_object == p); @@ -487,11 +618,39 @@ inline void ClassRegistry::unregister_class(Class* p) static_class_object = 0; } +template +void ClassRegistry::register_base_class(py::detail::BaseClassInfo const & i) +{ + static_base_class_info.push_back(i); +} + +template +void ClassRegistry::register_derived_class(py::detail::DerivedClassInfo const & i) +{ + static_derived_class_info.push_back(i); +} + +template +std::vector const& ClassRegistry::base_classes() +{ + return static_base_class_info; +} + +template +std::vector const& ClassRegistry::derived_classes() +{ + return static_derived_class_info; +} + // // Static data member declaration. // template -Class* ClassRegistry::static_class_object; +ExtensionClassBase* ClassRegistry::static_class_object; +template +std::vector ClassRegistry::static_base_class_info; +template +std::vector ClassRegistry::static_derived_class_info; } // namespace py diff --git a/extclass_demo.cpp b/extclass_demo.cpp index dd6c13f5..0334e0cd 100644 --- a/extclass_demo.cpp +++ b/extclass_demo.cpp @@ -8,6 +8,7 @@ #include "extclass_demo.h" #include "class_wrapper.h" #include // used for portability on broken compilers +#include namespace extclass_demo { @@ -290,6 +291,245 @@ long range_hash(const Range& r) return r.m_start * 123 + r.m_finish; } +/************************************************************/ +/* */ +/* some functions to test overloading */ +/* */ +/************************************************************/ + +static std::string testVoid() +{ + return std::string("Hello world!"); +} + +static int testInt(int i) +{ + return i; +} + +static std::string testString(std::string i) +{ + return i; +} + +static int test2(int i1, int i2) +{ + return i1+i2; +} + +static int test3(int i1, int i2, int i3) +{ + return i1+i2+i3; +} + +static int test4(int i1, int i2, int i3, int i4) +{ + return i1+i2+i3+i4; +} + +static int test5(int i1, int i2, int i3, int i4, int i5) +{ + return i1+i2+i3+i4+i5; +} + +/************************************************************/ +/* */ +/* a class to test overloading */ +/* */ +/************************************************************/ + +struct OverloadTest +{ + OverloadTest(): x_(1000) {} + OverloadTest(int x): x_(x) {} + OverloadTest(int x,int y): x_(x+y) { } + OverloadTest(int x,int y,int z): x_(x+y+z) {} + OverloadTest(int x,int y,int z, int a): x_(x+y+z+a) {} + OverloadTest(int x,int y,int z, int a, int b): x_(x+y+z+a+b) {} + + int x() const { return x_; } + void setX(int x) { x_ = x; } + + int p1(int x) { return x; } + int p2(int x, int y) { return x + y; } + int p3(int x, int y, int z) { return x + y + z; } + int p4(int x, int y, int z, int a) { return x + y + z + a; } + int p5(int x, int y, int z, int a, int b) { return x + y + z + a + b; } + private: + int x_; +}; + +static int getX(OverloadTest * u) +{ + return u->x(); +} + + +/************************************************************/ +/* */ +/* classes to test base declarations and conversions */ +/* */ +/************************************************************/ + +struct Dummy +{ + virtual ~Dummy() {} + int dummy_; +}; + +struct Base +{ + virtual int x() const { return 999; }; + virtual ~Base() {} +}; + +// inherit Dummy so that the Base part of Concrete starts at an offset +// otherwise, typecast tests wouldn't be very meaningful +struct Derived1 : public Dummy, public Base +{ + Derived1(int x): x_(x) {} + virtual int x() const { return x_; } + + private: + int x_; +}; + +struct Derived2 : public Dummy, public Base +{ + Derived2(int x): x_(x) {} + virtual int x() const { return x_; } + + private: + int x_; +}; + +static int testUpcast(Base * b) +{ + return b->x(); +} + +static std::auto_ptr derived1Factory(int i) +{ + return std::auto_ptr(new Derived1(i)); +} + +static std::auto_ptr derived2Factory(int i) +{ + return std::auto_ptr(new Derived2(i)); +} + +static int testDowncast1(Derived1 * d) +{ + return d->x(); +} + +static int testDowncast2(Derived2 * d) +{ + return d->x(); +} + +/************************************************************/ +/* */ +/* test classes for interaction of overloading, */ +/* base declarations, and callbacks */ +/* */ +/************************************************************/ + +struct CallbackTestBase +{ + virtual int testCallback(int i) { return callback(i); } + virtual int callback(int i) = 0; + virtual ~CallbackTestBase() {} +}; + +struct CallbackTest : public CallbackTestBase +{ + virtual int callback(int i) { return i + 1; } + virtual std::string callbackString(std::string const & i) { return i + " 1"; } +}; + +struct CallbackTestCallback : public CallbackTest +{ + CallbackTestCallback(PyObject* self) + : m_self(self) + {} + + int callback(int x) + { + return py::Callback::call_method(m_self, "callback", x); + } + std::string callbackString(std::string const & x) + { + return py::Callback::call_method(m_self, "callback", x); + } + + static int default_callback(CallbackTest * self, int x) + { + return self->CallbackTest::callback(x); + } + static std::string default_callbackString(CallbackTest * self, std::string x) + { + return self->CallbackTest::callbackString(x); + } + + PyObject * m_self; +}; + +int testCallback(CallbackTestBase * b, int i) +{ + return b->testCallback(i); +} + +typedef boost::rational Ratio; + +py::String ratio_str(const Ratio& r) +{ + char buf[200]; + + if (r.denominator() == 1) + sprintf(buf, "%d", r.numerator()); + else + sprintf(buf, "%d/%d", r.numerator(), r.denominator()); + + return py::String(buf); +} + +py::String ratio_repr(const Ratio& r) +{ + char buf[200]; + sprintf(buf, "Rational(%d, %d)", r.numerator(), r.denominator()); + return py::String(buf); +} + +py::Tuple ratio_coerce(const Ratio& r1, int r2) +{ + return py::Tuple(r1, Ratio(r2)); +} + +// The most reliable way, across compilers, to grab the particular abs function +// we're interested in. +Ratio ratio_abs(const Ratio& r) +{ + return boost::abs(r); +} + +// An experiment, to be integrated into the py_cpp library at some point. +template +struct StandardOps +{ + static T add(const T& x, const T& y) { return x + y; } + static T sub(const T& x, const T& y) { return x - y; } + static T mul(const T& x, const T& y) { return x * y; } + static T div(const T& x, const T& y) { return x / y; } + static T cmp(const T& x, const T& y) { return std::less()(x, y) ? -1 : std::less()(y, x) ? 1 : 0; } +}; + +/************************************************************/ +/* */ +/* init the module */ +/* */ +/************************************************************/ + void init_module(py::Module& m) { m.add(new Foo::PythonClass); @@ -309,6 +549,21 @@ void init_module(py::Module& m) m.def(first_string, "first_string"); m.def(second_string, "second_string"); + // This shows the wrapping of a 3rd-party numeric type. + py::ClassWrapper > rational(m, "Rational"); + rational.def(py::Constructor()); + rational.def(py::Constructor()); + rational.def(py::Constructor<>()); + rational.def(StandardOps::add, "__add__"); + rational.def(StandardOps::sub, "__sub__"); + rational.def(StandardOps::mul, "__mul__"); + rational.def(StandardOps::div, "__div__"); + rational.def(StandardOps::cmp, "__cmp__"); + rational.def(ratio_coerce, "__coerce__"); + rational.def(ratio_str, "__str__"); + rational.def(ratio_repr, "__repr__"); + rational.def(ratio_abs, "__abs__"); + py::ClassWrapper range(m, "Range"); range.def(py::Constructor()); range.def(py::Constructor()); @@ -321,6 +576,64 @@ void init_module(py::Module& m) range.def(&range_hash, "__hash__"); range.def_readonly(&Range::m_start, "start"); range.def_readonly(&Range::m_finish, "finish"); + + m.def(&testVoid, "overloaded"); + m.def(&testInt, "overloaded"); + m.def(&testString, "overloaded"); + m.def(&test2, "overloaded"); + m.def(&test3, "overloaded"); + m.def(&test4, "overloaded"); + m.def(&test5, "overloaded"); + + py::ClassWrapper over(m, "OverloadTest"); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(py::Constructor()); + over.def(&getX, "getX"); + over.def(&OverloadTest::setX, "setX"); + over.def(&OverloadTest::x, "overloaded"); + over.def(&OverloadTest::p1, "overloaded"); + over.def(&OverloadTest::p2, "overloaded"); + over.def(&OverloadTest::p3, "overloaded"); + over.def(&OverloadTest::p4, "overloaded"); + over.def(&OverloadTest::p5, "overloaded"); + + py::ClassWrapper base(m, "Base"); + base.def(&Base::x, "x"); + + py::ClassWrapper derived1(m, "Derived1"); + // this enables conversions between Base and Derived1 + // and makes wrapped methods of Base available + derived1.declare_base(base); + derived1.def(py::Constructor()); + + py::ClassWrapper derived2(m, "Derived2"); + // don't enable downcast from Base to Derived2 + derived2.declare_base(base, py::without_downcast); + derived2.def(py::Constructor()); + + m.def(&testUpcast, "testUpcast"); + m.def(&derived1Factory, "derived1Factory"); + m.def(&derived2Factory, "derived2Factory"); + m.def(&testDowncast1, "testDowncast1"); + m.def(&testDowncast2, "testDowncast2"); + + py::ClassWrapper callbackTestBase(m, "CallbackTestBase"); + callbackTestBase.def(&CallbackTestBase::testCallback, "testCallback"); + m.def(&testCallback, "testCallback"); + + py::ClassWrapper callbackTest(m, "CallbackTest"); + callbackTest.def(py::Constructor()); + callbackTest.def(&CallbackTest::callback, "callback", + &CallbackTestCallback::default_callback); + callbackTest.def(&CallbackTest::callbackString, "callback", + &CallbackTestCallback::default_callbackString); + + callbackTest.declare_base(callbackTestBase); } void init_module() diff --git a/gcc.mak b/gcc.mak index 00cea9e5..cec872cf 100644 --- a/gcc.mak +++ b/gcc.mak @@ -11,7 +11,15 @@ LIBSRC = \ LIBOBJ = $(LIBSRC:.cpp=.o) OBJ = $(LIBOBJ) extclass_demo.o + +ifeq "$(OS)" "Windows_NT" +PYTHON_LIB=c:/tools/python/libs/python15.lib +INC = -Ic:/cygnus/usr/include/g++-3 -Ic:/cygnus/usr/include -Ic:/boost -Ic:/tools/python/include +MODULE_EXTENSION=dll +else INC = -I/home/koethe/include -I/home/koethe/C++/boost -I/home/koethe/python/include/python1.5 +MODULE_EXTENSION=so +endif %.o: %.cpp g++ -fPIC $(INC) -c $*.cpp @@ -23,11 +31,11 @@ INC = -I/home/koethe/include -I/home/koethe/C++/boost -I/home/koethe/python/incl [ -s $@ ] || rm -f $@ demo: extclass_demo.o libpycpp.a - g++ -shared -o demomodule.so extclass_demo.o -L. -lpycpp + g++ -shared -o demomodule.$(MODULE_EXTENSION) $(PYTHON_LIB) extclass_demo.o -L. -lpycpp python test_extclass.py clean: - rm -rf *.o *.so *.a *.d *.pyc *.bak a.out + rm -rf *.o *.$(MODULE_EXTENSION) *.a *.d *.pyc *.bak a.out libpycpp.a: $(LIBOBJ) rm -f libpycpp.a diff --git a/newtypes.cpp b/newtypes.cpp index e0b4223f..8c75795b 100644 --- a/newtypes.cpp +++ b/newtypes.cpp @@ -86,21 +86,13 @@ static MethodStruct* enable_method(const MethodStruct* base, MemberPtr p, Fn f) return const_cast(detail::UniquePodSet::instance().get(new_value)); } -// TODO: is there a problem with calling convention here, or can I really pass a -// pointer to a C++ linkage function as a C-linkage function pointer? The -// compilers seem to swallow it, but is it legal? Symantec C++ for Mac didn't -// behave this way, FWIW. -// Using C++ linkage allows us to keep the virtual function members of -// TypeObjectBase private and use friendship to get them called. +namespace { -extern "C" { - -static PyObject* do_instance_repr(PyObject* instance) +PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*) const) { try { - return static_cast(instance->ob_type) - ->instance_repr(instance); + return (static_cast(instance->ob_type)->*f)(instance); } catch(...) { @@ -109,12 +101,14 @@ static PyObject* do_instance_repr(PyObject* instance) } } -static int do_instance_compare(PyObject* instance, PyObject* other) +// Naming this differently allows us to use it for functions returning long on +// compilers without partial ordering +template +R int_call(PyObject* instance, R (TypeObjectBase::*f)(PyObject*) const) { try { - return static_cast(instance->ob_type) - ->instance_compare(instance, other); + return (static_cast(instance->ob_type)->*f)(instance); } catch(...) { @@ -123,12 +117,18 @@ static int do_instance_compare(PyObject* instance, PyObject* other) } } -static PyObject* do_instance_str(PyObject* instance) +// Implemented in terms of int_call, above +int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*) const) +{ + return int_call(instance, f); +} + +template +PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*, A1) const, A1 a1) { try { - return static_cast(instance->ob_type) - ->instance_str(instance); + return (static_cast(instance->ob_type)->*f)(instance, a1); } catch(...) { @@ -137,12 +137,40 @@ static PyObject* do_instance_str(PyObject* instance) } } -static long do_instance_hash(PyObject* instance) +template +int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1) const, A1 a1) { try { - return static_cast(instance->ob_type) - ->instance_hash(instance); + return (static_cast(instance->ob_type)->*f)(instance, a1); + } + catch(...) + { + handle_exception(); + return -1; + } +} + +template +PyObject* call(PyObject* instance, PyObject* (TypeObjectBase::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2) +{ + try + { + return (static_cast(instance->ob_type)->*f)(instance, a1, a2); + } + catch(...) + { + handle_exception(); + return 0; + } +} + +template +int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1, A2) const, A1 a1, A2 a2) +{ + try + { + return (static_cast(instance->ob_type)->*f)(instance, a1, a2); } catch(...) { @@ -151,20 +179,70 @@ static long do_instance_hash(PyObject* instance) } } -static PyObject* do_instance_call(PyObject* instance, PyObject* args, PyObject* keywords) +template +int call(PyObject* instance, int (TypeObjectBase::*f)(PyObject*, A1, A2, A3) const, A1 a1, A2 a2, A3 a3) { try { - return static_cast(instance->ob_type) - ->instance_call(instance, args, keywords); + return (static_cast(instance->ob_type)->*f)(instance, a1, a2, a3); } catch(...) { handle_exception(); - return 0; + return -1; } } +int call_length_function(PyObject* instance, int (TypeObjectBase::*f)(PyObject*) const) +{ + try + { + const int outcome = + (static_cast(instance->ob_type)->*f)(instance); + + if (outcome < 0) + { + PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0"); + return -1; + } + return outcome; + } + catch(...) + { + handle_exception(); + return -1; + } +} + +} + +extern "C" { + +static PyObject* do_instance_repr(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_repr); +} + +static int do_instance_compare(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_compare, other); +} + +static PyObject* do_instance_str(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_str); +} + +static long do_instance_hash(PyObject* instance) +{ + return int_call(instance, &TypeObjectBase::instance_hash); +} + +static PyObject* do_instance_call(PyObject* instance, PyObject* args, PyObject* keywords) +{ + return call(instance, &TypeObjectBase::instance_call, args, keywords); +} + static void do_instance_dealloc(PyObject* instance) { try @@ -181,88 +259,29 @@ static void do_instance_dealloc(PyObject* instance) static PyObject* do_instance_getattr(PyObject* instance, char* name) { - try - { - return static_cast(instance->ob_type) - ->instance_getattr(instance, name); - } - catch(...) - { - handle_exception(); - return 0; - } + const char* name_ = name; + return call(instance, &TypeObjectBase::instance_getattr, name_); } static int do_instance_setattr(PyObject* instance, char* name, PyObject* value) { - try - { - return static_cast(instance->ob_type) - ->instance_setattr(instance, name, value); - } - catch(...) - { - handle_exception(); - return -1; - } + const char* name_ = name; + return call(instance, &TypeObjectBase::instance_setattr, name_, value); } static int do_instance_mp_length(PyObject* instance) { - try - { - const int outcome = - static_cast(instance->ob_type) - ->instance_mapping_length(instance); - - if (outcome < 0) - { - PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0"); - return -1; - } - return outcome; - } - catch(...) - { - handle_exception(); - return -1; - } + return call_length_function(instance, &TypeObjectBase::instance_mapping_length); } static int do_instance_sq_length(PyObject* instance) { - try - { - const int outcome = - static_cast(instance->ob_type) - ->instance_sequence_length(instance); - - if (outcome < 0) - { - PyErr_SetString(PyExc_ValueError, "__len__() should return >= 0"); - return -1; - } - return outcome; - } - catch(...) - { - handle_exception(); - return -1; - } + return call_length_function(instance, &TypeObjectBase::instance_sequence_length); } static PyObject* do_instance_mp_subscript(PyObject* instance, PyObject* index) { - try - { - return static_cast(instance->ob_type) - ->instance_mapping_subscript(instance, index); - } - catch(...) - { - handle_exception(); - return 0; - } + return call(instance, &TypeObjectBase::instance_mapping_subscript, index); } static PyObject* do_instance_sq_item(PyObject* instance, int index) @@ -293,88 +312,149 @@ static PyObject* do_instance_sq_item(PyObject* instance, int index) static int do_instance_mp_ass_subscript(PyObject* instance, PyObject* index, PyObject* value) { - try - { - return static_cast(instance->ob_type) - ->instance_mapping_ass_subscript(instance, index, value); - } - catch(...) - { - handle_exception(); - return -1; - } + return call(instance, &TypeObjectBase::instance_mapping_ass_subscript, index, value); } static int do_instance_sq_ass_item(PyObject* instance, int index, PyObject* value) { - try - { - return static_cast(instance->ob_type) - ->instance_sequence_ass_item(instance, index, value); - } - catch(...) - { - handle_exception(); - return -1; - } + return call(instance, &TypeObjectBase::instance_sequence_ass_item, index, value); } static PyObject* do_instance_sq_concat(PyObject* instance, PyObject* other) { - try - { - return static_cast(instance->ob_type) - ->instance_sequence_concat(instance, other); - } - catch(...) - { - handle_exception(); - return 0; - } + return call(instance, &TypeObjectBase::instance_sequence_concat, other); } static PyObject* do_instance_sq_repeat(PyObject* instance, int n) { - try - { - return static_cast(instance->ob_type) - ->instance_sequence_repeat(instance, n); - } - catch(...) - { - handle_exception(); - return 0; - } + return call(instance, &TypeObjectBase::instance_sequence_repeat, n); } static PyObject* do_instance_sq_slice( PyObject* instance, int start, int finish) { - try - { - return static_cast(instance->ob_type) - ->instance_sequence_slice(instance, start, finish); - } - catch(...) - { - handle_exception(); - return 0; - } + return call(instance, &TypeObjectBase::instance_sequence_slice, start, finish); } static int do_instance_sq_ass_slice( PyObject* instance, int start, int finish, PyObject* value) { - try - { - return static_cast(instance->ob_type) - ->instance_sequence_ass_slice(instance, start, finish, value); - } - catch(...) - { - handle_exception(); - return -1; - } + return call(instance, &TypeObjectBase::instance_sequence_ass_slice, start, finish, value); +} + +static PyObject* do_instance_nb_add(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_add, other); +} + +static PyObject* do_instance_nb_subtract(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_subtract, other); +} + +static PyObject* do_instance_nb_multiply(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_multiply, other); +} + +static PyObject* do_instance_nb_divide(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_divide, other); +} + +static PyObject* do_instance_nb_remainder(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_remainder, other); +} + +static PyObject* do_instance_nb_divmod(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_divmod, other); +} + +static PyObject* do_instance_nb_power(PyObject* instance, PyObject* exponent, PyObject* modulus) +{ + return call(instance, &TypeObjectBase::instance_number_power, exponent, modulus); +} + +static PyObject* do_instance_nb_negative(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_negative); +} + +static PyObject* do_instance_nb_positive(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_positive); +} + +static PyObject* do_instance_nb_absolute(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_absolute); +} + +static int do_instance_nb_nonzero(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_nonzero); +} + +static PyObject* do_instance_nb_invert(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_invert); +} + + +static PyObject* do_instance_nb_lshift(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_lshift, other); +} + +static PyObject* do_instance_nb_rshift(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_rshift, other); +} + +static PyObject* do_instance_nb_and(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_and, other); +} + +static PyObject* do_instance_nb_xor(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_xor, other); +} + +static PyObject* do_instance_nb_or(PyObject* instance, PyObject* other) +{ + return call(instance, &TypeObjectBase::instance_number_or, other); +} + +static int do_instance_nb_coerce(PyObject**instance, PyObject**other) +{ + return call(*instance, &TypeObjectBase::instance_number_coerce, instance, other); +} +static PyObject* do_instance_nb_int(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_int); +} + +static PyObject* do_instance_nb_long(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_long); +} + +static PyObject* do_instance_nb_float(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_float); +} + +static PyObject* do_instance_nb_oct(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_oct); +} + +static PyObject* do_instance_nb_hex(PyObject* instance) +{ + return call(instance, &TypeObjectBase::instance_number_hex); } } @@ -402,6 +482,7 @@ template struct category_type; DECLARE_CAPABILITY_TYPE(mapping, PyMappingMethods); DECLARE_CAPABILITY_TYPE(sequence, PySequenceMethods); +DECLARE_CAPABILITY_TYPE(number, PyNumberMethods); const CapabilityEntry capabilities[] = { CAPABILITY(hash), @@ -422,7 +503,31 @@ const CapabilityEntry capabilities[] = { CAPABILITY2(sequence, sq_concat), CAPABILITY2(sequence, sq_repeat), CAPABILITY2(sequence, sq_slice), - CAPABILITY2(sequence, sq_ass_slice) + CAPABILITY2(sequence, sq_ass_slice), + + CAPABILITY2(number, nb_add), + CAPABILITY2(number, nb_subtract), + CAPABILITY2(number, nb_multiply), + CAPABILITY2(number, nb_divide), + CAPABILITY2(number, nb_remainder), + CAPABILITY2(number, nb_divmod), + CAPABILITY2(number, nb_power), + CAPABILITY2(number, nb_negative), + CAPABILITY2(number, nb_positive), + CAPABILITY2(number, nb_absolute), + CAPABILITY2(number, nb_nonzero), + CAPABILITY2(number, nb_invert), + CAPABILITY2(number, nb_lshift), + CAPABILITY2(number, nb_rshift), + CAPABILITY2(number, nb_and), + CAPABILITY2(number, nb_xor), + CAPABILITY2(number, nb_or), + CAPABILITY2(number, nb_coerce), + CAPABILITY2(number, nb_int), + CAPABILITY2(number, nb_long), + CAPABILITY2(number, nb_float), + CAPABILITY2(number, nb_oct), + CAPABILITY2(number, nb_hex) }; const std::size_t num_capabilities = PY_ARRAY_LENGTH(capabilities); @@ -621,6 +726,121 @@ int TypeObjectBase::instance_sequence_ass_slice(PyObject*, int, int, PyObject*) return unimplemented("instance_sequence_ass_slice"); } +PyObject* TypeObjectBase::instance_number_add(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_add"); +} + +PyObject* TypeObjectBase::instance_number_subtract(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_subtract"); +} + +PyObject* TypeObjectBase::instance_number_multiply(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_multiply"); +} + +PyObject* TypeObjectBase::instance_number_divide(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_divide"); +} + +PyObject* TypeObjectBase::instance_number_remainder(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_remainder"); +} + +PyObject* TypeObjectBase::instance_number_divmod(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_divmod"); +} + +PyObject* TypeObjectBase::instance_number_power(PyObject*, PyObject*, PyObject*) const +{ + return unimplemented("instance_number_divmod"); +} + +PyObject* TypeObjectBase::instance_number_negative(PyObject*) const +{ + return unimplemented("instance_number_negative"); +} + +PyObject* TypeObjectBase::instance_number_positive(PyObject*) const +{ + return unimplemented("instance_number_positive"); +} + +PyObject* TypeObjectBase::instance_number_absolute(PyObject*) const +{ + return unimplemented("instance_number_absolute"); +} + +int TypeObjectBase::instance_number_nonzero(PyObject*) const +{ + return unimplemented("instance_number_nonzero"); +} + +PyObject* TypeObjectBase::instance_number_invert(PyObject*) const +{ + return unimplemented("instance_number_invert"); +} + +PyObject* TypeObjectBase::instance_number_lshift(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_lshift"); +} + +PyObject* TypeObjectBase::instance_number_rshift(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_rshift"); +} + +PyObject* TypeObjectBase::instance_number_and(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_and"); +} + +PyObject* TypeObjectBase::instance_number_xor(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_xor"); +} + +PyObject* TypeObjectBase::instance_number_or(PyObject*, PyObject*) const +{ + return unimplemented("instance_number_or"); +} + +int TypeObjectBase::instance_number_coerce(PyObject*, PyObject**, PyObject**) const +{ + return unimplemented("instance_number_coerce"); +} + +PyObject* TypeObjectBase::instance_number_int(PyObject*) const +{ + return unimplemented("instance_number_int"); +} + +PyObject* TypeObjectBase::instance_number_long(PyObject*) const +{ + return unimplemented("instance_number_long"); +} + +PyObject* TypeObjectBase::instance_number_float(PyObject*) const +{ + return unimplemented("instance_number_float"); +} + +PyObject* TypeObjectBase::instance_number_oct(PyObject*) const +{ + return unimplemented("instance_number_oct"); +} + +PyObject* TypeObjectBase::instance_number_hex(PyObject*) const +{ + return unimplemented("instance_number_hex"); +} + TypeObjectBase::~TypeObjectBase() { } diff --git a/newtypes.h b/newtypes.h index 94382232..ec8839a8 100644 --- a/newtypes.h +++ b/newtypes.h @@ -30,6 +30,8 @@ namespace py { +class InstanceHolderBase; + class TypeObjectBase : public PythonType { public: @@ -42,7 +44,14 @@ class TypeObjectBase : public PythonType hash, call, str, getattr, setattr, compare, repr, mapping_length, mapping_subscript, mapping_ass_subscript, sequence_length, sequence_item, sequence_ass_item, - sequence_concat, sequence_repeat, sequence_slice, sequence_ass_slice + sequence_concat, sequence_repeat, sequence_slice, sequence_ass_slice, + + number_add, number_subtract, number_multiply, number_divide, + number_remainder, number_divmod, number_power, number_negative, + number_positive, number_absolute, number_nonzero, number_invert, + number_lshift, number_rshift, number_and, number_xor, number_or, + number_coerce, number_int, number_long, number_float, number_oct, + number_hex }; void enable(Capability); @@ -75,7 +84,31 @@ class TypeObjectBase : public PythonType virtual PyObject* instance_sequence_slice(PyObject* instance, int start, int finish) const; virtual int instance_sequence_ass_item(PyObject* instance, int n, PyObject* value) const; virtual int instance_sequence_ass_slice(PyObject* instance, int start, int finish, PyObject* value) const; - + + public: // Callbacks for number methods + virtual PyObject* instance_number_add(PyObject*, PyObject*) const; + virtual PyObject* instance_number_subtract(PyObject*, PyObject*) const; + virtual PyObject* instance_number_multiply(PyObject*, PyObject*) const; + virtual PyObject* instance_number_divide(PyObject*, PyObject*) const; + virtual PyObject* instance_number_remainder(PyObject*, PyObject*) const; + virtual PyObject* instance_number_divmod(PyObject*, PyObject*) const; + virtual PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const; + virtual PyObject* instance_number_negative(PyObject*) const; + virtual PyObject* instance_number_positive(PyObject*) const; + virtual PyObject* instance_number_absolute(PyObject*) const; + virtual int instance_number_nonzero(PyObject*) const; + virtual PyObject* instance_number_invert(PyObject*) const; + virtual PyObject* instance_number_lshift(PyObject*, PyObject*) const; + virtual PyObject* instance_number_rshift(PyObject*, PyObject*) const; + virtual PyObject* instance_number_and(PyObject*, PyObject*) const; + virtual PyObject* instance_number_xor(PyObject*, PyObject*) const; + virtual PyObject* instance_number_or(PyObject*, PyObject*) const; + virtual int instance_number_coerce(PyObject*, PyObject**, PyObject**) const; + virtual PyObject* instance_number_int(PyObject*) const; + virtual PyObject* instance_number_long(PyObject*) const; + virtual PyObject* instance_number_float(PyObject*) const; + virtual PyObject* instance_number_oct(PyObject*) const; + virtual PyObject* instance_number_hex(PyObject*) const; }; template diff --git a/objects.h b/objects.h index c2d1eabe..4f54befc 100644 --- a/objects.h +++ b/objects.h @@ -13,6 +13,7 @@ # include "pyconfig.h" # include "pyptr.h" # include "boost/operators.hpp" +# include namespace py { @@ -36,8 +37,31 @@ class Tuple : public Object public: Tuple(std::size_t n = 0); explicit Tuple(Ptr p); + + template + Tuple(const std::pair& x) + : Object(Ptr(PyTuple_New(2))) + { + set_item(0, Ptr(to_python(x.first))); + set_item(1, Ptr(to_python(x.second))); + } - Tuple(const Ptr* start, const Ptr* finish); // not yet implemented. + template + Tuple(const First& first, const Second& second) + : Object(Ptr(PyTuple_New(2))) + { + set_item(0, Ptr(to_python(first))); + set_item(1, Ptr(to_python(second))); + } + + template + Tuple(const First& first, const Second& second, const Third& third) + : Object(Ptr(PyTuple_New(3))) + { + set_item(0, Ptr(to_python(first))); + set_item(1, Ptr(to_python(second))); + set_item(2, Ptr(to_python(third))); + } static PyTypeObject* type_object(); static bool accepts(Ptr p); diff --git a/py.cpp b/py.cpp index a64e27c5..9ac2490d 100644 --- a/py.cpp +++ b/py.cpp @@ -7,7 +7,11 @@ // producing this work. #include "py.h" -#include +#include +#include +#ifndef BOOST_NO_LIMITS +# include +#endif namespace py { @@ -82,11 +86,19 @@ T integer_from_python(PyObject* p, py::Type) { const long long_result = from_python(p, py::Type()); +#ifndef BOOST_NO_LIMITS try { return boost::numeric_cast(long_result); } catch(const boost::bad_numeric_cast&) +#else + if (static_cast(long_result) == long_result) + { + return static_cast(long_result); + } + else +#endif { char buffer[256]; const char message[] = "%ld out of range for %s"; @@ -103,12 +115,17 @@ template PyObject* integer_to_python(T value) { long value_as_long; - + +#ifndef BOOST_NO_LIMITS try { - value_as_long = boost::numeric_cast(value); + value_as_long = boost::numeric_cast(value); } catch(const boost::bad_numeric_cast&) +#else + value_as_long = static_cast(value); + if (value_as_long != value) +#endif { const char message[] = "value out of range for Python int"; PyErr_SetString(PyExc_ValueError, message); diff --git a/py.h b/py.h index 2cf89807..06365764 100644 --- a/py.h +++ b/py.h @@ -165,6 +165,11 @@ PyObject* to_python(boost::shared_ptr p) // inline implementations // +inline PyObject* to_python(double d) +{ + return PyFloat_FromDouble(d); +} + inline PyObject* to_python(long l) { return PyInt_FromLong(l); diff --git a/py_cpp.html b/py_cpp.html index c65f4a1b..03ff2677 100644 --- a/py_cpp.html +++ b/py_cpp.html @@ -18,12 +18,12 @@ Python.

    The source code for py_cpp, including a MSVC demo project is available - here. It has been tested against Python + here. It has been tested against Python 1.5.2 with GCC 2.95.2, Metrowerks CodeWarrior Pro6 and with Microsoft Visual C++ 6 sp4 using both the STLport standard library implementation and the library implementation which ships with the compiler. It has also been tested - against Python 2.0c1 with an unknown version of MSVC++ by Alex Martelli. + against Python 2.0c1 with MSVC++ 6sp4 by Alex Martelli. Py_cpp requires the Boost libraries, and is currently under formal review on the boost mailing list for @@ -116,5 +116,5 @@ express or implied warranty, and with no claim as to its suitability for any purpose.

    - Updated: Oct 15, 2000 + Updated: Oct 18, 2000 diff --git a/py_cpp_20001013.zip b/py_cpp_20001013.zip deleted file mode 100644 index 420d2bc4b7e4098439b30e4fcbc865b8d0682bce..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 104507 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 diff --git a/subclass.cpp b/subclass.cpp index 3f1d25ec..3a133be0 100644 --- a/subclass.cpp +++ b/subclass.cpp @@ -38,12 +38,8 @@ PyObject* Instance::getattr(const char* name, bool use_special_function) } else { - // Suspend the error while we try special methods method (if any). -#if 0 - SuspendError suspended_error(SuspendError::discard_new_error); -#else + // Clear the error while we try special methods method (if any). PyErr_Clear(); -#endif // First we try the special method that comes from concatenating // "__getattr__" and and 2 trailing underscores. This is an @@ -67,15 +63,11 @@ PyObject* Instance::getattr(const char* name, bool use_special_function) } // If there is no such method, throw now. -#if 0 - suspended_error.throw_if_error(); -#else if (PyErr_Occurred()) { PyErr_SetString(PyExc_AttributeError, name); throw ErrorAlreadySet(); } -#endif // Take ownership of the method Ptr owner(getattr_method); @@ -224,6 +216,131 @@ void Instance::set_slice(int start, int finish, PyObject* value) Callback::call_method(this, "__setslice__", start, finish, value); } +PyObject* Instance::add(PyObject* other) +{ + return Callback::call_method(this, "__add__", other); +} + +PyObject* Instance::subtract(PyObject* other) +{ + return Callback::call_method(this, "__sub__", other); +} + +PyObject* Instance::multiply(PyObject* other) +{ + return Callback::call_method(this, "__mul__", other); +} + +PyObject* Instance::divide(PyObject* other) +{ + return Callback::call_method(this, "__div__", other); +} + +PyObject* Instance::remainder(PyObject* other) +{ + return Callback::call_method(this, "__mod__", other); +} + +PyObject* Instance::divmod(PyObject* other) +{ + return Callback::call_method(this, "__divmod__", other); +} + +PyObject* Instance::power(PyObject* exponent, PyObject* modulus) +{ + if (as_object(modulus->ob_type) == Py_None) + return Callback::call_method(this, "__pow__", exponent); + else + return Callback::call_method(this, "__pow__", exponent, modulus); +} + +PyObject* Instance::negative() +{ + return Callback::call_method(this, "__neg__"); +} + +PyObject* Instance::positive() +{ + return Callback::call_method(this, "__pos__"); +} + +PyObject* Instance::absolute() +{ + return Callback::call_method(this, "__abs__"); +} + +int Instance::nonzero() +{ + return Callback::call_method(this, "__nonzero__"); +} + +PyObject* Instance::invert() +{ + return Callback::call_method(this, "__invert__"); +} + +PyObject* Instance::lshift(PyObject* other) +{ + return Callback::call_method(this, "__lshift__", other); +} + +PyObject* Instance::rshift(PyObject* other) +{ + return Callback::call_method(this, "__rshift__", other); +} + +PyObject* Instance::do_and(PyObject* other) +{ + return Callback::call_method(this, "__and__", other); +} + +PyObject* Instance::do_xor(PyObject* other) +{ + return Callback::call_method(this, "__xor__", other); +} + +PyObject* Instance::do_or(PyObject* other) +{ + return Callback::call_method(this, "__or__", other); +} + +int Instance::coerce(PyObject** x, PyObject** y) +{ + assert(this == *x); + + // Coerce must return a tuple + Tuple result(Callback::call_method(this, "__coerce__", *y)); + + *x = result[0].release(); + *y = result[1].release(); + return 0; +} + +PyObject* Instance::as_int() +{ + return Callback::call_method(this, "__int__"); +} + +PyObject* Instance::as_long() +{ + return Callback::call_method(this, "__long__"); +} + +PyObject* Instance::as_float() +{ + return Callback::call_method(this, "__float__"); +} + +PyObject* Instance::oct() +{ + return Callback::call_method(this, "__oct__"); +} + +PyObject* Instance::hex() +{ + return Callback::call_method(this, "__hex__"); +} + namespace { struct NamedCapability { @@ -250,7 +367,30 @@ namespace { { "__delitem__", TypeObjectBase::sequence_ass_item }, { "__getslice__", TypeObjectBase::sequence_slice }, { "__setslice__", TypeObjectBase::sequence_ass_slice }, - { "__delslice__", TypeObjectBase::sequence_ass_slice } + { "__delslice__", TypeObjectBase::sequence_ass_slice }, + { "__add__", TypeObjectBase::number_add }, + { "__sub__", TypeObjectBase::number_subtract }, + { "__mul__", TypeObjectBase::number_multiply }, + { "__div__", TypeObjectBase::number_divide }, + { "__mod__", TypeObjectBase::number_remainder }, + { "__divmod__", TypeObjectBase::number_divmod }, + { "__pow__", TypeObjectBase::number_power }, + { "__neg__", TypeObjectBase::number_negative }, + { "__pos__", TypeObjectBase::number_positive }, + { "__abs__", TypeObjectBase::number_absolute }, + { "__nonzero__", TypeObjectBase::number_nonzero }, + { "__invert__", TypeObjectBase::number_invert }, + { "__lshift__", TypeObjectBase::number_lshift }, + { "__rshift__", TypeObjectBase::number_rshift }, + { "__and__", TypeObjectBase::number_and }, + { "__xor__", TypeObjectBase::number_xor }, + { "__or__", TypeObjectBase::number_or }, + { "__coerce__", TypeObjectBase::number_coerce }, + { "__int__", TypeObjectBase::number_int }, + { "__long__", TypeObjectBase::number_long }, + { "__float__", TypeObjectBase::number_float }, + { "__oct__", TypeObjectBase::number_oct }, + { "__hex__", TypeObjectBase::number_hex } }; bool is_prefix(const char* s1, const char* s2) diff --git a/subclass.h b/subclass.h index 4d745bc0..a442ca30 100644 --- a/subclass.h +++ b/subclass.h @@ -44,7 +44,32 @@ class Instance : public PythonObject // Sequence methods PyObject* get_slice(int start, int finish); void set_slice(int start, int finish, PyObject* value); - + + // Number methods + PyObject* add(PyObject* other); + PyObject* subtract(PyObject* other); + PyObject* multiply(PyObject* other); + PyObject* divide(PyObject* other); + PyObject* remainder(PyObject* other); + PyObject* divmod(PyObject* other); + PyObject* power(PyObject*, PyObject*); + PyObject* negative(); + PyObject* positive(); + PyObject* absolute(); + int nonzero(); + PyObject* invert(); + PyObject* lshift(PyObject* other); + PyObject* rshift(PyObject* other); + PyObject* do_and(PyObject* other); + PyObject* do_xor(PyObject* other); + PyObject* do_or(PyObject* other); + int coerce(PyObject**, PyObject**); + PyObject* as_int(); + PyObject* as_long(); + PyObject* as_float(); + PyObject* oct(); + PyObject* hex(); + private: // noncopyable, without the size bloat Instance(const Instance&); void operator=(const Instance&); @@ -92,6 +117,31 @@ class Class PyObject* instance_sequence_slice(PyObject*, int start, int finish) const; int instance_sequence_ass_slice(PyObject*, int start, int finish, PyObject* value) const; + private: // Implement number methods on instances + PyObject* instance_number_add(PyObject*, PyObject*) const; + PyObject* instance_number_subtract(PyObject*, PyObject*) const; + PyObject* instance_number_multiply(PyObject*, PyObject*) const; + PyObject* instance_number_divide(PyObject*, PyObject*) const; + PyObject* instance_number_remainder(PyObject*, PyObject*) const; + PyObject* instance_number_divmod(PyObject*, PyObject*) const; + PyObject* instance_number_power(PyObject*, PyObject*, PyObject*) const; + PyObject* instance_number_negative(PyObject*) const; + PyObject* instance_number_positive(PyObject*) const; + PyObject* instance_number_absolute(PyObject*) const; + int instance_number_nonzero(PyObject*) const; + PyObject* instance_number_invert(PyObject*) const; + PyObject* instance_number_lshift(PyObject*, PyObject*) const; + PyObject* instance_number_rshift(PyObject*, PyObject*) const; + PyObject* instance_number_and(PyObject*, PyObject*) const; + PyObject* instance_number_xor(PyObject*, PyObject*) const; + PyObject* instance_number_or(PyObject*, PyObject*) const; + int instance_number_coerce(PyObject*, PyObject**, PyObject**) const; + PyObject* instance_number_int(PyObject*) const; + PyObject* instance_number_long(PyObject*) const; + PyObject* instance_number_float(PyObject*) const; + PyObject* instance_number_oct(PyObject*) const; + PyObject* instance_number_hex(PyObject*) const; + private: // Miscellaneous "special" methods PyObject* instance_call(PyObject* instance, PyObject* args, PyObject* keywords) const; @@ -316,6 +366,144 @@ PyObject* Class::instance_call(PyObject* instance, PyObject* args, PyObject* return Downcast(instance)->call(args, keywords); } +template +PyObject* Class::instance_number_add(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->add(other); +} + +template +PyObject* Class::instance_number_subtract(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->subtract(other); +} + +template +PyObject* Class::instance_number_multiply(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->multiply(other); +} + +template +PyObject* Class::instance_number_divide(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->divide(other); +} + +template +PyObject* Class::instance_number_remainder(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->remainder(other); +} + +template +PyObject* Class::instance_number_divmod(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->divmod(other); +} + +template +PyObject* Class::instance_number_power(PyObject* instance, PyObject* exponent, PyObject* modulus) const +{ + return Downcast(instance)->power(exponent, modulus); +} + +template +PyObject* Class::instance_number_negative(PyObject* instance) const +{ + return Downcast(instance)->negative(); +} + +template +PyObject* Class::instance_number_positive(PyObject* instance) const +{ + return Downcast(instance)->positive(); +} + +template +PyObject* Class::instance_number_absolute(PyObject* instance) const +{ + return Downcast(instance)->absolute(); +} + +template +int Class::instance_number_nonzero(PyObject* instance) const +{ + return Downcast(instance)->nonzero(); +} + +template +PyObject* Class::instance_number_invert(PyObject* instance) const +{ + return Downcast(instance)->invert(); +} + +template +PyObject* Class::instance_number_lshift(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->lshift(other); +} + +template +PyObject* Class::instance_number_rshift(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->rshift(other); +} + +template +PyObject* Class::instance_number_and(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->do_and(other); +} + +template +PyObject* Class::instance_number_xor(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->do_xor(other); +} + +template +PyObject* Class::instance_number_or(PyObject* instance, PyObject* other) const +{ + return Downcast(instance)->do_or(other); +} + +template +int Class::instance_number_coerce(PyObject* instance, PyObject** x, PyObject** y) const +{ + return Downcast(instance)->coerce(x, y); +} + +template +PyObject* Class::instance_number_int(PyObject* instance) const +{ + return Downcast(instance)->as_int(); +} + +template +PyObject* Class::instance_number_long(PyObject* instance) const +{ + return Downcast(instance)->as_long(); +} + +template +PyObject* Class::instance_number_float(PyObject* instance) const +{ + return Downcast(instance)->as_float(); +} + +template +PyObject* Class::instance_number_oct(PyObject* instance) const +{ + return Downcast(instance)->oct(); +} + +template +PyObject* Class::instance_number_hex(PyObject* instance) const +{ + return Downcast(instance)->hex(); +} + template Dict& Class::dict() { diff --git a/test_extclass.py b/test_extclass.py index a458dbb0..8861aa06 100644 --- a/test_extclass.py +++ b/test_extclass.py @@ -130,7 +130,7 @@ But objects not derived from Bar cannot: >>> baz.pass_bar(baz) Traceback (innermost last): ... - TypeError: extension class 'Baz' is not derived from 'Bar'. + TypeError: extension class 'Baz' is not convertible into 'Bar'. The clone function on Baz returns a smart pointer; we wrap it into an ExtensionInstance and make it look just like any other Baz instance. @@ -264,6 +264,22 @@ Sequence tests: >>> map(lambda x:x, Range(3, 10)[0:4]) [3, 4, 5, 6] +Numeric tests: + >>> x = Rational(2,3) + >>> y = Rational(1,4) + >>> print x + y + 11/12 + >>> print x - y + 5/12 + >>> print x * y + 1/6 + >>> print x / y + 8/3 + >>> print x + 1 # testing coercion + 5/3 + >>> print 1 + x # coercion the other way + 5/3 + delete non-existent attribute: del m.foobar Traceback (innermost last): @@ -412,6 +428,146 @@ Testing __call__: 0 >>> comparator(couple2, couple) 1 + +Testing overloaded free functions + >>> overloaded() + 'Hello world!' + >>> overloaded(1) + 1 + >>> overloaded('foo') + 'foo' + >>> overloaded(1,2) + 3 + >>> overloaded(1,2,3) + 6 + >>> overloaded(1,2,3,4) + 10 + >>> overloaded(1,2,3,4,5) + 15 + >>> try: overloaded(1, 'foo') + ... except TypeError, err: + ... assert re.match("No overloaded functions match \(int, string\)\. Candidates are:", + ... str(err)) + ... else: + ... print 'no exception' + +Testing overloaded constructors + + >>> over = OverloadTest() + >>> over.getX() + 1000 + >>> over = OverloadTest(1) + >>> over.getX() + 1 + >>> over = OverloadTest(1,1) + >>> over.getX() + 2 + >>> over = OverloadTest(1,1,1) + >>> over.getX() + 3 + >>> over = OverloadTest(1,1,1,1) + >>> over.getX() + 4 + >>> over = OverloadTest(1,1,1,1,1) + >>> over.getX() + 5 + >>> over = OverloadTest(over) + >>> over.getX() + 5 + >>> try: over = OverloadTest(1, 'foo') + ... except TypeError, err: + ... assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:", + ... str(err)) + ... else: + ... print 'no exception' + +Testing overloaded methods + + >>> over.setX(3) + >>> over.overloaded() + 3 + >>> over.overloaded(1) + 1 + >>> over.overloaded(1,1) + 2 + >>> over.overloaded(1,1,1) + 3 + >>> over.overloaded(1,1,1,1) + 4 + >>> over.overloaded(1,1,1,1,1) + 5 + >>> try: over.overloaded(1,'foo') + ... except TypeError, err: + ... assert re.match("No overloaded functions match \(OverloadTest, int, string\)\. Candidates are:", + ... str(err)) + ... else: + ... print 'no exception' + +Testing base class conversions + + >>> testUpcast(over) + Traceback (innermost last): + TypeError: extension class 'OverloadTest' is not convertible into 'Base'. + >>> der1 = Derived1(333) + >>> der1.x() + 333 + >>> testUpcast(der1) + 333 + >>> der1 = derived1Factory(1000) + >>> testDowncast1(der1) + 1000 + >>> testDowncast2(der1) + Traceback (innermost last): + TypeError: extension class 'Base' is not convertible into 'Derived2'. + >>> der2 = Derived2(444) + >>> der2.x() + 444 + >>> testUpcast(der2) + 444 + >>> der2 = derived2Factory(1111) + >>> testDowncast2(der2) + Traceback (innermost last): + TypeError: extension class 'Base' is not convertible into 'Derived2'. + +Testing interaction between callbacks, base declarations, and overloading +- testCallback() calls callback() (within C++) +- callback() is overloaded (in the wrapped class CallbackTest) +- callback() is redefined in RedefineCallback (overloading is simulated by type casing) +- testCallback() should use the redefined callback() + + >>> c = CallbackTest() + >>> c.testCallback(1) + 2 + >>> c.testCallback('foo') + Traceback (innermost last): + File "", line 1, in ? + TypeError: illegal argument type for built-in operation + >>> c.callback(1) + 2 + >>> c.callback('foo') + 'foo 1' + + >>> import types + >>> class RedefineCallback(CallbackTest): + ... def callback(self, x): + ... if type(x) is types.IntType: + ... return x - 2 + ... else: + ... return CallbackTest.callback(self,x) + ... + >>> r = RedefineCallback() + >>> r.callback(1) + -1 + >>> r.callback('foo') + 'foo 1' + >>> r.testCallback('foo') + Traceback (innermost last): + File "", line 1, in ? + TypeError: illegal argument type for built-in operation + >>> r.testCallback(1) + -1 + >>> testCallback(r, 1) + -1 ''' from demo import * diff --git a/todo.txt b/todo.txt index 80514798..51967244 100644 --- a/todo.txt +++ b/todo.txt @@ -7,14 +7,15 @@ Report Cygwin linker memory issues handle more arguments MI from both ExtensionClasses and Python classes, or at least don't crash(!) Remove one level of indirection on type objects (no vtbl?). -Much more testing, especially of things in objects.h Make multiple inheritance from real Python classes work - I don't think this is possible Handle polymorphism (passing a Wrapped as a Base*). Specializations of Caller<> for commmon combinations of argument types (?) special member functions for numeric types pickling support testing with Python 2.0 -Make abstract classes non-instantiable +Make abstract classes non-instantiable (?) +Much more testing, especially of things in objects.h +Support for Python LONG types in Objects.h Documentation: building @@ -31,6 +32,7 @@ Documentation: differences between Python classes and ExtensionClasses additional capabilities of ExtensionClasses + slice adjustment exception handling diff --git a/vc6_prj/vc6_prj.opt b/vc6_prj/vc6_prj.opt new file mode 100644 index 0000000000000000000000000000000000000000..543c06adaf67ead0ab8afd5eafead6e85a806d06 GIT binary patch literal 66048 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 QXb6mkz$h3E0YV`F0J%!+h5!Hn literal 0 HcmV?d00001