diff --git a/src/CXX/IndirectPythonInterface.cxx b/src/CXX/IndirectPythonInterface.cxx index 7286cdf65..256bd7ebd 100644 --- a/src/CXX/IndirectPythonInterface.cxx +++ b/src/CXX/IndirectPythonInterface.cxx @@ -34,10 +34,524 @@ // DAMAGE. // //----------------------------------------------------------------------------- -#include "CXX/WrapPython.h" +#include "CXX/IndirectPythonInterface.hxx" + +namespace Py +{ +bool _CFunction_Check( PyObject *op ) { return op->ob_type == _CFunction_Type(); } +bool _Complex_Check( PyObject *op ) { return op->ob_type == _Complex_Type(); } +bool _Dict_Check( PyObject *op ) { return op->ob_type == _Dict_Type(); } +bool _Float_Check( PyObject *op ) { return op->ob_type == _Float_Type(); } +bool _Function_Check( PyObject *op ) { return op->ob_type == _Function_Type(); } +bool _Boolean_Check( PyObject *op ) { return op->ob_type == _Bool_Type(); } +bool _List_Check( PyObject *op ) { return op->ob_type == _List_Type(); } +bool _Long_Check( PyObject *op ) { return op->ob_type == _Long_Type(); } +bool _Method_Check( PyObject *op ) { return op->ob_type == _Method_Type(); } +bool _Module_Check( PyObject *op ) { return op->ob_type == _Module_Type(); } +bool _Range_Check( PyObject *op ) { return op->ob_type == _Range_Type(); } +bool _Slice_Check( PyObject *op ) { return op->ob_type == _Slice_Type(); } +bool _TraceBack_Check( PyObject *op ) { return op->ob_type == _TraceBack_Type(); } +bool _Tuple_Check( PyObject *op ) { return op->ob_type == _Tuple_Type(); } +bool _Type_Check( PyObject *op ) { return op->ob_type == _Type_Type(); } +bool _Unicode_Check( PyObject *op ) { return op->ob_type == _Unicode_Type(); } #if PY_MAJOR_VERSION == 2 -#include "Python2/IndirectPythonInterface.cxx" -#else -#include "Python3/IndirectPythonInterface.cxx" +bool _String_Check( PyObject *op ) { return op->ob_type == _String_Type(); } +bool _Int_Check( PyObject *op ) { return op->ob_type == _Int_Type(); } +bool _CObject_Check( PyObject *op ) { return op->ob_type == _CObject_Type(); } #endif +#if PY_MAJOR_VERSION >= 3 +bool _Bytes_Check( PyObject *op ) { return op->ob_type == _Bytes_Type(); } +#endif + +#if defined(PY_WIN32_DELAYLOAD_PYTHON_DLL) + +#if defined(MS_WINDOWS) +#include + + +static HMODULE python_dll; + +static PyObject *ptr__Exc_ArithmeticError = NULL; +static PyObject *ptr__Exc_AssertionError = NULL; +static PyObject *ptr__Exc_AttributeError = NULL; +static PyObject *ptr__Exc_EnvironmentError = NULL; +static PyObject *ptr__Exc_EOFError = NULL; +static PyObject *ptr__Exc_Exception = NULL; +static PyObject *ptr__Exc_FloatingPointError = NULL; +static PyObject *ptr__Exc_ImportError = NULL; +static PyObject *ptr__Exc_IndexError = NULL; +static PyObject *ptr__Exc_IOError = NULL; +static PyObject *ptr__Exc_KeyboardInterrupt = NULL; +static PyObject *ptr__Exc_KeyError = NULL; +static PyObject *ptr__Exc_LookupError = NULL; +static PyObject *ptr__Exc_MemoryError = NULL; +static PyObject *ptr__Exc_NameError = NULL; +static PyObject *ptr__Exc_NotImplementedError = NULL; +static PyObject *ptr__Exc_OSError = NULL; +static PyObject *ptr__Exc_OverflowError = NULL; +static PyObject *ptr__Exc_RuntimeError = NULL; +static PyObject *ptr__Exc_StandardError = NULL; +static PyObject *ptr__Exc_SyntaxError = NULL; +static PyObject *ptr__Exc_SystemError = NULL; +static PyObject *ptr__Exc_SystemExit = NULL; +static PyObject *ptr__Exc_TypeError = NULL; +static PyObject *ptr__Exc_ValueError = NULL; +static PyObject *ptr__Exc_ZeroDivisionError = NULL; + +#ifdef MS_WINDOWS +static PyObject *ptr__Exc_WindowsError = NULL; +#endif + +static PyObject *ptr__Exc_IndentationError = NULL; +static PyObject *ptr__Exc_TabError = NULL; +static PyObject *ptr__Exc_UnboundLocalError = NULL; +static PyObject *ptr__Exc_UnicodeError = NULL; +static PyObject *ptr__PyNone = NULL; +static PyObject *ptr__PyFalse = NULL; +static PyObject *ptr__PyTrue = NULL; +static PyTypeObject *ptr__CFunction_Type = NULL; +static PyTypeObject *ptr__Complex_Type = NULL; +static PyTypeObject *ptr__Dict_Type = NULL; +static PyTypeObject *ptr__Float_Type = NULL; +static PyTypeObject *ptr__Function_Type = NULL; +static PyTypeObject *ptr__Bool_Type = NULL; +static PyTypeObject *ptr__List_Type = NULL; +static PyTypeObject *ptr__Long_Type = NULL; +static PyTypeObject *ptr__Method_Type = NULL; +static PyTypeObject *ptr__Module_Type = NULL; +static PyTypeObject *ptr__Range_Type = NULL; +static PyTypeObject *ptr__Slice_Type = NULL; +static PyTypeObject *ptr__TraceBack_Type = NULL; +static PyTypeObject *ptr__Tuple_Type = NULL; +static PyTypeObject *ptr__Type_Type = NULL; +#if PY_MAJOR_VERSION == 2 +static PyTypeObject *ptr__Int_Type = NULL; +static PyTypeObject *ptr__String_Type = NULL; +static PyTypeObject *ptr__CObject_Type = NULL; +#endif +#if PY_MAJOR_VERSION >= 3 +static PyTypeObject *ptr__Bytes_Type = NULL; +#endif + + +static int *ptr_Py_DebugFlag = NULL; +static int *ptr_Py_InteractiveFlag = NULL; +static int *ptr_Py_OptimizeFlag = NULL; +static int *ptr_Py_NoSiteFlag = NULL; +static int *ptr_Py_VerboseFlag = NULL; + +static char **ptr__Py_PackageContext = NULL; + +#ifdef Py_REF_DEBUG +int *ptr_Py_RefTotal; +#endif + + +//-------------------------------------------------------------------------------- +class GetAddressException +{ +public: + GetAddressException( const char *_name ) + : name( _name ) + {} + virtual ~GetAddressException() {} + const char *name; +}; + + +//-------------------------------------------------------------------------------- +static PyObject *GetPyObjectPointer_As_PyObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return *(PyObject **)addr; +} + +static PyObject *GetPyObject_As_PyObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (PyObject *)addr; +} + +static PyTypeObject *GetPyTypeObjectPointer_As_PyTypeObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return *(PyTypeObject **)addr; +} + +static PyTypeObject *GetPyTypeObject_As_PyTypeObjectPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (PyTypeObject *)addr; +} + +static int *GetInt_as_IntPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (int *)addr; +} + +static char **GetCharPointer_as_CharPointerPointer( const char *name ) +{ + FARPROC addr = GetProcAddress( python_dll, name ); + if( addr == NULL ) + throw GetAddressException( name ); + + return (char **)addr; +} + + +#ifdef _DEBUG +static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d_D.DLL"; +#else +static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d.DLL"; +#endif + +//-------------------------------------------------------------------------------- +bool InitialisePythonIndirectInterface() +{ + char python_dll_name[sizeof(python_dll_name_format)]; + + _snprintf( python_dll_name, sizeof(python_dll_name_format) / sizeof(char) - 1, python_dll_name_format, PY_MAJOR_VERSION, PY_MINOR_VERSION ); + + python_dll = LoadLibraryA( python_dll_name ); + if( python_dll == NULL ) + return false; + + try + { +#ifdef Py_REF_DEBUG + ptr_Py_RefTotal = GetInt_as_IntPointer( "_Py_RefTotal" ); +#endif + ptr_Py_DebugFlag = GetInt_as_IntPointer( "Py_DebugFlag" ); + ptr_Py_InteractiveFlag = GetInt_as_IntPointer( "Py_InteractiveFlag" ); + ptr_Py_OptimizeFlag = GetInt_as_IntPointer( "Py_OptimizeFlag" ); + ptr_Py_NoSiteFlag = GetInt_as_IntPointer( "Py_NoSiteFlag" ); + ptr_Py_VerboseFlag = GetInt_as_IntPointer( "Py_VerboseFlag" ); + ptr__Py_PackageContext = GetCharPointer_as_CharPointerPointer( "_Py_PackageContext" ); + + ptr__Exc_ArithmeticError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ArithmeticError" ); + ptr__Exc_AssertionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AssertionError" ); + ptr__Exc_AttributeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AttributeError" ); + ptr__Exc_EnvironmentError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EnvironmentError" ); + ptr__Exc_EOFError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EOFError" ); + ptr__Exc_Exception = GetPyObjectPointer_As_PyObjectPointer( "PyExc_Exception" ); + ptr__Exc_FloatingPointError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_FloatingPointError" ); + ptr__Exc_ImportError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ImportError" ); + ptr__Exc_IndexError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndexError" ); + ptr__Exc_IOError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IOError" ); + ptr__Exc_KeyboardInterrupt = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyboardInterrupt" ); + ptr__Exc_KeyError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyError" ); + ptr__Exc_LookupError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_LookupError" ); + ptr__Exc_MemoryError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_MemoryError" ); + ptr__Exc_NameError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_NameError" ); + ptr__Exc_NotImplementedError= GetPyObjectPointer_As_PyObjectPointer( "PyExc_NotImplementedError" ); + ptr__Exc_OSError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OSError" ); + ptr__Exc_OverflowError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OverflowError" ); + ptr__Exc_RuntimeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_RuntimeError" ); + ptr__Exc_StandardError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_StandardError" ); + ptr__Exc_SyntaxError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SyntaxError" ); + ptr__Exc_SystemError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemError" ); + ptr__Exc_SystemExit = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemExit" ); + ptr__Exc_TypeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TypeError" ); + ptr__Exc_ValueError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ValueError" ); +#ifdef MS_WINDOWS + ptr__Exc_WindowsError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_WindowsError" ); +#endif + ptr__Exc_ZeroDivisionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ZeroDivisionError" ); + ptr__Exc_IndentationError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndentationError" ); + ptr__Exc_TabError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TabError" ); + ptr__Exc_UnboundLocalError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnboundLocalError" ); + ptr__Exc_UnicodeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnicodeError" ); + ptr__PyNone = GetPyObject_As_PyObjectPointer( "_Py_NoneStruct" ); + + ptr__PyFalse = GetPyObject_As_PyObjectPointer( "_Py_ZeroStruct" ); + ptr__PyTrue = GetPyObject_As_PyObjectPointer( "_Py_TrueStruct" ); + + ptr__CFunction_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCFunction_Type" ); + ptr__Complex_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyComplex_Type" ); + ptr__Dict_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyDict_Type" ); + ptr__Float_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFloat_Type" ); + ptr__Function_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFunction_Type" ); + ptr__Bool_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyBool_Type" ); + ptr__List_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyList_Type" ); + ptr__Long_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyLong_Type" ); + ptr__Method_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyMethod_Type" ); + ptr__Module_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyModule_Type" ); + ptr__Range_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyRange_Type" ); + ptr__Slice_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PySlice_Type" ); + ptr__TraceBack_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTraceBack_Type" ); + ptr__Tuple_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTuple_Type" ); + ptr__Type_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyType_Type" ); + ptr__Unicode_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyUnicode_Type" ); +#if PY_MAJOR_VERSION == 2 + ptr__String_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyString_Type" ); + ptr__Int_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyInt_Type" ); + ptr__CObject_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCObject_Type" ); +#endif +#if PY_MAJOR_VERSION >= 3 + ptr__Bytes_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyBytes_Type" ); +#endif + } + catch( GetAddressException &e ) + { + OutputDebugStringA( python_dll_name ); + OutputDebugStringA( " does not contain symbol " ); + OutputDebugStringA( e.name ); + OutputDebugStringA( "\n" ); + + return false; + } + + return true; +} + +// +// Wrap variables as function calls +// +PyObject *_Exc_ArithmeticError() { return ptr__Exc_ArithmeticError; } +PyObject *_Exc_AssertionError() { return ptr__Exc_AssertionError; } +PyObject *_Exc_AttributeError() { return ptr__Exc_AttributeError; } +PyObject *_Exc_EnvironmentError() { return ptr__Exc_EnvironmentError; } +PyObject *_Exc_EOFError() { return ptr__Exc_EOFError; } +PyObject *_Exc_Exception() { return ptr__Exc_Exception; } +PyObject *_Exc_FloatingPointError() { return ptr__Exc_FloatingPointError; } +PyObject *_Exc_ImportError() { return ptr__Exc_ImportError; } +PyObject *_Exc_IndexError() { return ptr__Exc_IndexError; } +PyObject *_Exc_IOError() { return ptr__Exc_IOError; } +PyObject *_Exc_KeyboardInterrupt() { return ptr__Exc_KeyboardInterrupt; } +PyObject *_Exc_KeyError() { return ptr__Exc_KeyError; } +PyObject *_Exc_LookupError() { return ptr__Exc_LookupError; } +PyObject *_Exc_MemoryError() { return ptr__Exc_MemoryError; } +PyObject *_Exc_NameError() { return ptr__Exc_NameError; } +PyObject *_Exc_NotImplementedError() { return ptr__Exc_NotImplementedError; } +PyObject *_Exc_OSError() { return ptr__Exc_OSError; } +PyObject *_Exc_OverflowError() { return ptr__Exc_OverflowError; } +PyObject *_Exc_RuntimeError() { return ptr__Exc_RuntimeError; } +PyObject *_Exc_StandardError() { return ptr__Exc_StandardError; } +PyObject *_Exc_SyntaxError() { return ptr__Exc_SyntaxError; } +PyObject *_Exc_SystemError() { return ptr__Exc_SystemError; } +PyObject *_Exc_SystemExit() { return ptr__Exc_SystemExit; } +PyObject *_Exc_TypeError() { return ptr__Exc_TypeError; } +PyObject *_Exc_ValueError() { return ptr__Exc_ValueError; } +#ifdef MS_WINDOWS +PyObject *_Exc_WindowsError() { return ptr__Exc_WindowsError; } +#endif +PyObject *_Exc_ZeroDivisionError() { return ptr__Exc_ZeroDivisionError; } +PyObject *_Exc_IndentationError() { return ptr__Exc_IndentationError; } +PyObject *_Exc_TabError() { return ptr__Exc_TabError; } +PyObject *_Exc_UnboundLocalError() { return ptr__Exc_UnboundLocalError; } +PyObject *_Exc_UnicodeError() { return ptr__Exc_UnicodeError; } + +// +// wrap items in Object.h +// +PyObject *_None() { return ptr__PyNone; } + +PyObject *_False() { return ptr__PyFalse; } +PyObject *_True() { return ptr__PyTrue; } + +PyTypeObject *_CFunction_Type() { return ptr__CFunction_Type; } +PyTypeObject *_Complex_Type() { return ptr__Complex_Type; } +PyTypeObject *_Dict_Type() { return ptr__Dict_Type; } +PyTypeObject *_Float_Type() { return ptr__Float_Type; } +PyTypeObject *_Function_Type() { return ptr__Function_Type; } +PyTypeObject *_Bool_Type() { return ptr__Bool_Type; } +PyTypeObject *_List_Type() { return ptr__List_Type; } +PyTypeObject *_Long_Type() { return ptr__Long_Type; } +PyTypeObject *_Method_Type() { return ptr__Method_Type; } +PyTypeObject *_Module_Type() { return ptr__Module_Type; } +PyTypeObject *_Range_Type() { return ptr__Range_Type; } +PyTypeObject *_Slice_Type() { return ptr__Slice_Type; } +PyTypeObject *_TraceBack_Type() { return ptr__TraceBack_Type; } +PyTypeObject *_Tuple_Type() { return ptr__Tuple_Type; } +PyTypeObject *_Type_Type() { return ptr__Type_Type; } +PyTypeObject *_Unicode_Type() { return ptr__Unicode_Type; } +#if PY_MAJOR_VERSION == 2 +PyTypeObject *_String_Type() { return ptr__String_Type; } +PyTypeObject *_Int_Type() { return ptr__Int_Type; } +PyTypeObject *_CObject_Type() { return ptr__CObject_Type; } +#endif +#if PY_MAJOR_VERSION >= 3 +PyTypeObject *_Bytes_Type() { return ptr__Bytes_Type; } +#endif + +char *__Py_PackageContext() { return *ptr__Py_PackageContext; } + + +// +// wrap the Python Flag variables +// +int &_Py_DebugFlag() { return *ptr_Py_DebugFlag; } +int &_Py_InteractiveFlag() { return *ptr_Py_InteractiveFlag; } +int &_Py_OptimizeFlag() { return *ptr_Py_OptimizeFlag; } +int &_Py_NoSiteFlag() { return *ptr_Py_NoSiteFlag; } +int &_Py_VerboseFlag() { return *ptr_Py_VerboseFlag; } + +#if 0 +#define Py_INCREF(op) ( \ + _Py_INC_REFTOTAL _Py_REF_DEBUG_COMMA \ + ((PyObject*)(op))->ob_refcnt++) + +#define Py_DECREF(op) \ + if (_Py_DEC_REFTOTAL _Py_REF_DEBUG_COMMA \ + --((PyObject*)(op))->ob_refcnt != 0) \ + _Py_CHECK_REFCNT(op) \ + else \ + _Py_Dealloc((PyObject *)(op)) +#endif + +void _XINCREF( PyObject *op ) +{ + // This function must match the contents of Py_XINCREF(op) + if( op == NULL ) + return; + +#ifdef Py_REF_DEBUG + (*ptr_Py_RefTotal)++; +#endif + (op)->ob_refcnt++; + +} + +void _XDECREF( PyObject *op ) +{ + // This function must match the contents of Py_XDECREF(op); + if( op == NULL ) + return; + +#ifdef Py_REF_DEBUG + (*ptr_Py_RefTotal)--; +#endif + + if (--(op)->ob_refcnt == 0) + _Py_Dealloc((PyObject *)(op)); +} + + +#else +#error "Can only delay load under Win32" +#endif + +#else + +//================================================================================ +// +// Map onto Macros +// +//================================================================================ + +// +// Wrap variables as function calls +// + +PyObject *_Exc_ArithmeticError() { return ::PyExc_ArithmeticError; } +PyObject *_Exc_AssertionError() { return ::PyExc_AssertionError; } +PyObject *_Exc_AttributeError() { return ::PyExc_AttributeError; } +PyObject *_Exc_EnvironmentError() { return ::PyExc_EnvironmentError; } +PyObject *_Exc_EOFError() { return ::PyExc_EOFError; } +PyObject *_Exc_Exception() { return ::PyExc_Exception; } +PyObject *_Exc_FloatingPointError() { return ::PyExc_FloatingPointError; } +PyObject *_Exc_ImportError() { return ::PyExc_ImportError; } +PyObject *_Exc_IndexError() { return ::PyExc_IndexError; } +PyObject *_Exc_IOError() { return ::PyExc_IOError; } +PyObject *_Exc_KeyboardInterrupt() { return ::PyExc_KeyboardInterrupt; } +PyObject *_Exc_KeyError() { return ::PyExc_KeyError; } +PyObject *_Exc_LookupError() { return ::PyExc_LookupError; } +PyObject *_Exc_MemoryError() { return ::PyExc_MemoryError; } +PyObject *_Exc_NameError() { return ::PyExc_NameError; } +PyObject *_Exc_NotImplementedError() { return ::PyExc_NotImplementedError; } +PyObject *_Exc_OSError() { return ::PyExc_OSError; } +PyObject *_Exc_OverflowError() { return ::PyExc_OverflowError; } +PyObject *_Exc_RuntimeError() { return ::PyExc_RuntimeError; } +PyObject *_Exc_SyntaxError() { return ::PyExc_SyntaxError; } +PyObject *_Exc_SystemError() { return ::PyExc_SystemError; } +PyObject *_Exc_SystemExit() { return ::PyExc_SystemExit; } +PyObject *_Exc_TypeError() { return ::PyExc_TypeError; } +PyObject *_Exc_ValueError() { return ::PyExc_ValueError; } +PyObject *_Exc_ZeroDivisionError() { return ::PyExc_ZeroDivisionError; } +PyObject *_Exc_IndentationError() { return ::PyExc_IndentationError; } +PyObject *_Exc_TabError() { return ::PyExc_TabError; } +PyObject *_Exc_UnboundLocalError() { return ::PyExc_UnboundLocalError; } +PyObject *_Exc_UnicodeError() { return ::PyExc_UnicodeError; } + +#ifdef MS_WINDOWS +PyObject *_Exc_WindowsError() { return ::PyExc_WindowsError; } +#endif + + + + +// +// wrap items in Object.h +// +PyObject *_None() { return &::_Py_NoneStruct; } + +PyObject *_False() { return Py_False; } +PyObject *_True() { return Py_True; } + +PyTypeObject *_CFunction_Type() { return &PyCFunction_Type; } +PyTypeObject *_Complex_Type() { return &PyComplex_Type; } +PyTypeObject *_Dict_Type() { return &PyDict_Type; } +PyTypeObject *_Float_Type() { return &PyFloat_Type; } +PyTypeObject *_Function_Type() { return &PyFunction_Type; } +PyTypeObject *_Bool_Type() { return &PyBool_Type; } +PyTypeObject *_List_Type() { return &PyList_Type; } +PyTypeObject *_Long_Type() { return &PyLong_Type; } +PyTypeObject *_Method_Type() { return &PyMethod_Type; } +PyTypeObject *_Module_Type() { return &PyModule_Type; } +PyTypeObject *_Range_Type() { return &PyRange_Type; } +PyTypeObject *_Slice_Type() { return &PySlice_Type; } +PyTypeObject *_TraceBack_Type() { return &PyTraceBack_Type; } +PyTypeObject *_Tuple_Type() { return &PyTuple_Type; } +PyTypeObject *_Type_Type() { return &PyType_Type; } +PyTypeObject *_Unicode_Type() { return &PyUnicode_Type; } +#if PY_MAJOR_VERSION == 2 +PyTypeObject *_String_Type() { return &PyString_Type; } +PyTypeObject *_Int_Type() { return &PyInt_Type; } +PyTypeObject *_CObject_Type() { return &PyCObject_Type; } +#endif +#if PY_MAJOR_VERSION >= 3 +PyTypeObject *_Bytes_Type() { return &PyBytes_Type; } +#endif + +// +// wrap flags +// +int &_Py_DebugFlag() { return Py_DebugFlag; } +int &_Py_InteractiveFlag() { return Py_InteractiveFlag; } +int &_Py_OptimizeFlag() { return Py_OptimizeFlag; } +int &_Py_NoSiteFlag() { return Py_NoSiteFlag; } +int &_Py_VerboseFlag() { return Py_VerboseFlag; } +char *__Py_PackageContext() { return _Py_PackageContext; } + +// +// Needed to keep the abstactions for delayload interface +// +void _XINCREF( PyObject *op ) +{ + Py_XINCREF( op ); +} + +void _XDECREF( PyObject *op ) +{ + Py_XDECREF( op ); +} + +#endif +} diff --git a/src/CXX/Python2/Config.hxx b/src/CXX/Python2/Config.hxx index 242fec781..b27f9ba28 100644 --- a/src/CXX/Python2/Config.hxx +++ b/src/CXX/Python2/Config.hxx @@ -114,19 +114,5 @@ #if PY_MAJOR_VERSION < 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION < 5) typedef int Py_ssize_t; #endif - -// export macro -#if defined( _MSC_VER ) -# pragma warning( disable : 4251 ) -#endif -#if defined( _MSC_VER ) || defined( __MINGW32__ ) -# ifdef PYCXX_DLL -# define PYCXX_EXPORT __declspec(dllexport) -# else -# define PYCXX_EXPORT __declspec(dllimport) -# endif -#else -# define PYCXX_EXPORT -#endif #endif // __PyCXX_config_hh__ diff --git a/src/CXX/Python2/Exception.hxx b/src/CXX/Python2/Exception.hxx index 2cf6a9616..3acc0ae41 100644 --- a/src/CXX/Python2/Exception.hxx +++ b/src/CXX/Python2/Exception.hxx @@ -53,7 +53,7 @@ namespace Py class Object; - class PYCXX_EXPORT Exception + class Exception { public: Exception( ExtensionExceptionType &exception, const std::string& reason ); @@ -83,28 +83,28 @@ namespace Py // Abstract - class PYCXX_EXPORT StandardError: public Exception + class StandardError: public Exception { protected: explicit StandardError() {} }; - class PYCXX_EXPORT LookupError: public StandardError + class LookupError: public StandardError { protected: explicit LookupError() {} }; - class PYCXX_EXPORT ArithmeticError: public StandardError + class ArithmeticError: public StandardError { protected: explicit ArithmeticError() {} }; - class PYCXX_EXPORT EnvironmentError: public StandardError + class EnvironmentError: public StandardError { protected: explicit EnvironmentError() @@ -113,7 +113,7 @@ namespace Py // Concrete - class PYCXX_EXPORT TypeError: public StandardError + class TypeError: public StandardError { public: TypeError (const std::string& reason) @@ -123,7 +123,7 @@ namespace Py } }; - class PYCXX_EXPORT IndexError: public LookupError + class IndexError: public LookupError { public: IndexError (const std::string& reason) @@ -133,7 +133,7 @@ namespace Py } }; - class PYCXX_EXPORT AttributeError: public StandardError + class AttributeError: public StandardError { public: AttributeError (const std::string& reason) @@ -143,7 +143,7 @@ namespace Py } }; - class PYCXX_EXPORT NameError: public StandardError + class NameError: public StandardError { public: NameError (const std::string& reason) @@ -153,7 +153,7 @@ namespace Py } }; - class PYCXX_EXPORT RuntimeError: public StandardError + class RuntimeError: public StandardError { public: RuntimeError (const std::string& reason) @@ -163,7 +163,17 @@ namespace Py } }; - class PYCXX_EXPORT SystemError: public StandardError + class NotImplementedError: public StandardError + { + public: + NotImplementedError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_NotImplementedError(), reason.c_str()); + } + }; + + class SystemError: public StandardError { public: SystemError (const std::string& reason) @@ -173,7 +183,7 @@ namespace Py } }; - class PYCXX_EXPORT KeyError: public LookupError + class KeyError: public LookupError { public: KeyError (const std::string& reason) @@ -184,7 +194,7 @@ namespace Py }; - class PYCXX_EXPORT ValueError: public StandardError + class ValueError: public StandardError { public: ValueError (const std::string& reason) @@ -194,7 +204,7 @@ namespace Py } }; - class PYCXX_EXPORT OverflowError: public ArithmeticError + class OverflowError: public ArithmeticError { public: OverflowError (const std::string& reason) @@ -204,7 +214,7 @@ namespace Py } }; - class PYCXX_EXPORT ZeroDivisionError: public ArithmeticError + class ZeroDivisionError: public ArithmeticError { public: ZeroDivisionError (const std::string& reason) @@ -214,7 +224,7 @@ namespace Py } }; - class PYCXX_EXPORT FloatingPointError: public ArithmeticError + class FloatingPointError: public ArithmeticError { public: FloatingPointError (const std::string& reason) @@ -224,7 +234,7 @@ namespace Py } }; - class PYCXX_EXPORT MemoryError: public StandardError + class MemoryError: public StandardError { public: MemoryError (const std::string& reason) @@ -234,7 +244,7 @@ namespace Py } }; - class PYCXX_EXPORT SystemExit: public StandardError + class SystemExit: public StandardError { public: SystemExit (const std::string& reason) diff --git a/src/CXX/Python2/ExtensionModule.hxx b/src/CXX/Python2/ExtensionModule.hxx index dca683d3d..3eb436d00 100644 --- a/src/CXX/Python2/ExtensionModule.hxx +++ b/src/CXX/Python2/ExtensionModule.hxx @@ -40,7 +40,7 @@ namespace Py { - class PYCXX_EXPORT ExtensionModuleBase + class ExtensionModuleBase { public: ExtensionModuleBase( const char *name ); @@ -66,9 +66,6 @@ namespace Py const std::string m_module_name; const std::string m_full_module_name; MethodTable m_method_table; -#if PY3 - PyModuleDef m_module_def; -#endif PyObject *m_module; private: @@ -80,11 +77,11 @@ namespace Py }; // Note: Python calls noargs as varargs buts args==NULL - extern "C" PYCXX_EXPORT PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ); - extern "C" PYCXX_EXPORT PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ); - extern "C" PYCXX_EXPORT PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ); + extern "C" PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ); + extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ); + extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ); - extern "C" PYCXX_EXPORT void do_not_dealloc( void * ); + extern "C" void do_not_dealloc( void * ); template class ExtensionModule : public ExtensionModuleBase @@ -139,8 +136,8 @@ namespace Py static PyObject *self = PyCObject_FromVoidPtr( this, do_not_dealloc ); Tuple args( 2 ); - args[0] = Object( self ); - args[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ) ); + args[0] = Object( self, true ); + args[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ), true ); PyObject *func = PyCFunction_New ( diff --git a/src/CXX/Python2/ExtensionOldType.hxx b/src/CXX/Python2/ExtensionOldType.hxx index 5e1355b14..cfd2fbe6a 100644 --- a/src/CXX/Python2/ExtensionOldType.hxx +++ b/src/CXX/Python2/ExtensionOldType.hxx @@ -178,7 +178,7 @@ namespace Py Tuple self( 2 ); self[0] = Object( this ); - self[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ) ); + self[1] = Object( PyCObject_FromVoidPtr( method_def, do_not_dealloc ), true ); PyObject *func = PyCFunction_New( &method_def->ext_meth_def, self.ptr() ); diff --git a/src/CXX/Python2/ExtensionType.hxx b/src/CXX/Python2/ExtensionType.hxx index d87b098bb..4128960ee 100644 --- a/src/CXX/Python2/ExtensionType.hxx +++ b/src/CXX/Python2/ExtensionType.hxx @@ -113,7 +113,7 @@ namespace Py }; - class PYCXX_EXPORT ExtensionClassMethodsTable + class ExtensionClassMethodsTable { public: ExtensionClassMethodsTable() diff --git a/src/CXX/Python2/ExtensionTypeBase.hxx b/src/CXX/Python2/ExtensionTypeBase.hxx index 56954cb34..1dfe42436 100644 --- a/src/CXX/Python2/ExtensionTypeBase.hxx +++ b/src/CXX/Python2/ExtensionTypeBase.hxx @@ -59,7 +59,7 @@ namespace Py // This special deallocator does a delete on the pointer. - class PYCXX_EXPORT PythonExtensionBase : public PyObject + class PythonExtensionBase : public PyObject { public: PythonExtensionBase(); @@ -70,9 +70,7 @@ namespace Py virtual void reinit( Tuple &args, Dict &kwds ); // object basics -#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 ) virtual int print( FILE *, int ); -#endif virtual Object getattr( const char * ); virtual int setattr( const char *, const Object & ); virtual Object getattro( const String & ); diff --git a/src/CXX/Python2/Extensions.hxx b/src/CXX/Python2/Extensions.hxx index ad9a5ebb2..c4324b30a 100644 --- a/src/CXX/Python2/Extensions.hxx +++ b/src/CXX/Python2/Extensions.hxx @@ -63,7 +63,7 @@ namespace Py class ExtensionModuleBase; // Make an Exception Type for use in raising custom exceptions - class PYCXX_EXPORT ExtensionExceptionType : public Object + class ExtensionExceptionType : public Object { public: ExtensionExceptionType(); @@ -74,7 +74,7 @@ namespace Py void init( ExtensionModuleBase &module, const std::string &name ); }; - class PYCXX_EXPORT MethodTable + class MethodTable { public: MethodTable(); diff --git a/src/CXX/Python2/IndirectPythonInterface.cxx b/src/CXX/Python2/IndirectPythonInterface.cxx deleted file mode 100644 index d36d1b526..000000000 --- a/src/CXX/Python2/IndirectPythonInterface.cxx +++ /dev/null @@ -1,597 +0,0 @@ -//----------------------------------------------------------------------------- -// -// Copyright (c) 1998 - 2007, The Regents of the University of California -// Produced at the Lawrence Livermore National Laboratory -// All rights reserved. -// -// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The -// full copyright notice is contained in the file COPYRIGHT located at the root -// of the PyCXX distribution. -// -// Redistribution and use in source and binary forms, with or without -// modification, are permitted provided that the following conditions are met: -// -// - Redistributions of source code must retain the above copyright notice, -// this list of conditions and the disclaimer below. -// - Redistributions in binary form must reproduce the above copyright notice, -// this list of conditions and the disclaimer (as noted below) in the -// documentation and/or materials provided with the distribution. -// - Neither the name of the UC/LLNL nor the names of its contributors may be -// used to endorse or promote products derived from this software without -// specific prior written permission. -// -// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE -// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF -// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR -// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH -// DAMAGE. -// -//----------------------------------------------------------------------------- - -#include "CXX/IndirectPythonInterface.hxx" - -namespace Py -{ -bool _Buffer_Check( PyObject *op ) { return (op)->ob_type == _Buffer_Type(); } -bool _CFunction_Check( PyObject *op ) { return (op)->ob_type == _CFunction_Type(); } -bool _Class_Check( PyObject *op ) { return (op)->ob_type == _Class_Type(); } -bool _CObject_Check( PyObject *op ) { return (op)->ob_type == _CObject_Type(); } -bool _Complex_Check( PyObject *op ) { return (op)->ob_type == _Complex_Type(); } -bool _Dict_Check( PyObject *op ) { return (op)->ob_type == _Dict_Type(); } -bool _File_Check( PyObject *op ) { return (op)->ob_type == _File_Type(); } -bool _Float_Check( PyObject *op ) { return (op)->ob_type == _Float_Type(); } -bool _Function_Check( PyObject *op ) { return (op)->ob_type == _Function_Type(); } -bool _Instance_Check( PyObject *op ) { return (op)->ob_type == _Instance_Type(); } -bool _Boolean_Check( PyObject *op ) { return (op)->ob_type == _Bool_Type(); } -bool _Int_Check( PyObject *op ) { return (op)->ob_type == _Int_Type(); } -bool _List_Check( PyObject *o ) { return o->ob_type == _List_Type(); } -bool _Long_Check( PyObject *op ) { return (op)->ob_type == _Long_Type(); } -bool _Method_Check( PyObject *op ) { return (op)->ob_type == _Method_Type(); } -bool _Module_Check( PyObject *op ) { return (op)->ob_type == _Module_Type(); } -bool _Range_Check( PyObject *op ) { return (op)->ob_type == _Range_Type(); } -bool _Slice_Check( PyObject *op ) { return (op)->ob_type == _Slice_Type(); } -bool _String_Check( PyObject *o ) { return o->ob_type == _String_Type(); } -bool _TraceBack_Check( PyObject *v ) { return (v)->ob_type == _TraceBack_Type(); } -bool _Tuple_Check( PyObject *op ) { return (op)->ob_type == _Tuple_Type(); } -bool _Type_Check( PyObject *op ) { return (op)->ob_type == _Type_Type(); } - -#if PY_MAJOR_VERSION >= 2 -bool _Unicode_Check( PyObject *op ) { return (op)->ob_type == _Unicode_Type(); } -#endif - - - -#if defined(PY_WIN32_DELAYLOAD_PYTHON_DLL) - -#if defined(MS_WINDOWS) -#include - - -static HMODULE python_dll; - -static PyObject *ptr__Exc_ArithmeticError = NULL; -static PyObject *ptr__Exc_AssertionError = NULL; -static PyObject *ptr__Exc_AttributeError = NULL; -static PyObject *ptr__Exc_EnvironmentError = NULL; -static PyObject *ptr__Exc_EOFError = NULL; -static PyObject *ptr__Exc_Exception = NULL; -static PyObject *ptr__Exc_FloatingPointError = NULL; -static PyObject *ptr__Exc_ImportError = NULL; -static PyObject *ptr__Exc_IndexError = NULL; -static PyObject *ptr__Exc_IOError = NULL; -static PyObject *ptr__Exc_KeyboardInterrupt = NULL; -static PyObject *ptr__Exc_KeyError = NULL; -static PyObject *ptr__Exc_LookupError = NULL; -static PyObject *ptr__Exc_MemoryError = NULL; -static PyObject *ptr__Exc_MemoryErrorInst = NULL; -static PyObject *ptr__Exc_NameError = NULL; -static PyObject *ptr__Exc_NotImplementedError = NULL; -static PyObject *ptr__Exc_OSError = NULL; -static PyObject *ptr__Exc_OverflowError = NULL; -static PyObject *ptr__Exc_RuntimeError = NULL; -static PyObject *ptr__Exc_StandardError = NULL; -static PyObject *ptr__Exc_SyntaxError = NULL; -static PyObject *ptr__Exc_SystemError = NULL; -static PyObject *ptr__Exc_SystemExit = NULL; -static PyObject *ptr__Exc_TypeError = NULL; -static PyObject *ptr__Exc_ValueError = NULL; -static PyObject *ptr__Exc_ZeroDivisionError = NULL; - -#ifdef MS_WINDOWS -static PyObject *ptr__Exc_WindowsError = NULL; -#endif - -#if PY_MAJOR_VERSION >= 2 -static PyObject *ptr__Exc_IndentationError = NULL; -static PyObject *ptr__Exc_TabError = NULL; -static PyObject *ptr__Exc_UnboundLocalError = NULL; -static PyObject *ptr__Exc_UnicodeError = NULL; -#endif - -static PyObject *ptr__PyNone = NULL; - -static PyObject *ptr__PyFalse = NULL; -static PyObject *ptr__PyTrue = NULL; - -static PyTypeObject *ptr__Buffer_Type = NULL; -static PyTypeObject *ptr__CFunction_Type = NULL; -static PyTypeObject *ptr__Class_Type = NULL; -static PyTypeObject *ptr__CObject_Type = NULL; -static PyTypeObject *ptr__Complex_Type = NULL; -static PyTypeObject *ptr__Dict_Type = NULL; -static PyTypeObject *ptr__File_Type = NULL; -static PyTypeObject *ptr__Float_Type = NULL; -static PyTypeObject *ptr__Function_Type = NULL; -static PyTypeObject *ptr__Instance_Type = NULL; -static PyTypeObject *ptr__Int_Type = NULL; -static PyTypeObject *ptr__List_Type = NULL; -static PyTypeObject *ptr__Long_Type = NULL; -static PyTypeObject *ptr__Method_Type = NULL; -static PyTypeObject *ptr__Module_Type = NULL; -static PyTypeObject *ptr__Range_Type = NULL; -static PyTypeObject *ptr__Slice_Type = NULL; -static PyTypeObject *ptr__String_Type = NULL; -static PyTypeObject *ptr__TraceBack_Type = NULL; -static PyTypeObject *ptr__Tuple_Type = NULL; -static PyTypeObject *ptr__Type_Type = NULL; - -#if PY_MAJOR_VERSION >= 2 -static PyTypeObject *ptr__Unicode_Type = NULL; -#endif - -static int *ptr_Py_DebugFlag = NULL; -static int *ptr_Py_InteractiveFlag = NULL; -static int *ptr_Py_OptimizeFlag = NULL; -static int *ptr_Py_NoSiteFlag = NULL; -static int *ptr_Py_TabcheckFlag = NULL; -static int *ptr_Py_VerboseFlag = NULL; - -#if PY_MAJOR_VERSION >= 2 -static int *ptr_Py_UnicodeFlag = NULL; -#endif - -static char **ptr__Py_PackageContext = NULL; - -#ifdef Py_REF_DEBUG -int *ptr_Py_RefTotal; -#endif - - -//-------------------------------------------------------------------------------- -class GetAddressException -{ -public: - GetAddressException( const char *_name ) - : name( _name ) - {} - virtual ~GetAddressException() {} - const char *name; -}; - - -//-------------------------------------------------------------------------------- -static PyObject *GetPyObjectPointer_As_PyObjectPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return *(PyObject **)addr; -} - -static PyObject *GetPyObject_As_PyObjectPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return (PyObject *)addr; -} - -static PyTypeObject *GetPyTypeObjectPointer_As_PyTypeObjectPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return *(PyTypeObject **)addr; -} - -static PyTypeObject *GetPyTypeObject_As_PyTypeObjectPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return (PyTypeObject *)addr; -} - -static int *GetInt_as_IntPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return (int *)addr; -} - -static char **GetCharPointer_as_CharPointerPointer( const char *name ) -{ - FARPROC addr = GetProcAddress( python_dll, name ); - if( addr == NULL ) - throw GetAddressException( name ); - - return (char **)addr; -} - - -#ifdef _DEBUG -static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d_D.DLL"; -#else -static const char python_dll_name_format[] = "PYTHON%1.1d%1.1d.DLL"; -#endif - -//-------------------------------------------------------------------------------- -bool InitialisePythonIndirectInterface() -{ - char python_dll_name[sizeof(python_dll_name_format)]; - - sprintf( python_dll_name, python_dll_name_format, PY_MAJOR_VERSION, PY_MINOR_VERSION ); - - python_dll = LoadLibrary( python_dll_name ); - if( python_dll == NULL ) - return false; - - try -{ -#ifdef Py_REF_DEBUG - ptr_Py_RefTotal = GetInt_as_IntPointer( "_Py_RefTotal" ); -#endif - ptr_Py_DebugFlag = GetInt_as_IntPointer( "Py_DebugFlag" ); - ptr_Py_InteractiveFlag = GetInt_as_IntPointer( "Py_InteractiveFlag" ); - ptr_Py_OptimizeFlag = GetInt_as_IntPointer( "Py_OptimizeFlag" ); - ptr_Py_NoSiteFlag = GetInt_as_IntPointer( "Py_NoSiteFlag" ); - ptr_Py_TabcheckFlag = GetInt_as_IntPointer( "Py_TabcheckFlag" ); - ptr_Py_VerboseFlag = GetInt_as_IntPointer( "Py_VerboseFlag" ); -#if PY_MAJOR_VERSION >= 2 - ptr_Py_UnicodeFlag = GetInt_as_IntPointer( "Py_UnicodeFlag" ); -#endif - ptr__Py_PackageContext = GetCharPointer_as_CharPointerPointer( "_Py_PackageContext" ); - - ptr__Exc_ArithmeticError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ArithmeticError" ); - ptr__Exc_AssertionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AssertionError" ); - ptr__Exc_AttributeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_AttributeError" ); - ptr__Exc_EnvironmentError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EnvironmentError" ); - ptr__Exc_EOFError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_EOFError" ); - ptr__Exc_Exception = GetPyObjectPointer_As_PyObjectPointer( "PyExc_Exception" ); - ptr__Exc_FloatingPointError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_FloatingPointError" ); - ptr__Exc_ImportError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ImportError" ); - ptr__Exc_IndexError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndexError" ); - ptr__Exc_IOError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IOError" ); - ptr__Exc_KeyboardInterrupt = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyboardInterrupt" ); - ptr__Exc_KeyError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_KeyError" ); - ptr__Exc_LookupError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_LookupError" ); - ptr__Exc_MemoryError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_MemoryError" ); - ptr__Exc_MemoryErrorInst = GetPyObjectPointer_As_PyObjectPointer( "PyExc_MemoryErrorInst" ); - ptr__Exc_NameError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_NameError" ); - ptr__Exc_NotImplementedError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_NotImplementedError" ); - ptr__Exc_OSError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OSError" ); - ptr__Exc_OverflowError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_OverflowError" ); - ptr__Exc_RuntimeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_RuntimeError" ); - ptr__Exc_StandardError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_StandardError" ); - ptr__Exc_SyntaxError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SyntaxError" ); - ptr__Exc_SystemError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemError" ); - ptr__Exc_SystemExit = GetPyObjectPointer_As_PyObjectPointer( "PyExc_SystemExit" ); - ptr__Exc_TypeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TypeError" ); - ptr__Exc_ValueError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ValueError" ); -#ifdef MS_WINDOWS - ptr__Exc_WindowsError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_WindowsError" ); -#endif - ptr__Exc_ZeroDivisionError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_ZeroDivisionError" ); - -#if PY_MAJOR_VERSION >= 2 - ptr__Exc_IndentationError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_IndentationError" ); - ptr__Exc_TabError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_TabError" ); - ptr__Exc_UnboundLocalError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnboundLocalError" ); - ptr__Exc_UnicodeError = GetPyObjectPointer_As_PyObjectPointer( "PyExc_UnicodeError" ); -#endif - ptr__PyNone = GetPyObject_As_PyObjectPointer( "_Py_NoneStruct" ); - - ptr__PyFalse = GetPyObject_As_PyObjectPointer( "_Py_ZeroStruct" ); - ptr__PyTrue = GetPyObject_As_PyObjectPointer( "_Py_TrueStruct" ); - - ptr__Buffer_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyBuffer_Type" ); - ptr__CFunction_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCFunction_Type" ); - ptr__Class_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyClass_Type" ); - ptr__CObject_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyCObject_Type" ); - ptr__Complex_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyComplex_Type" ); - ptr__Dict_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyDict_Type" ); - ptr__File_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFile_Type" ); - ptr__Float_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFloat_Type" ); - ptr__Function_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyFunction_Type" ); - ptr__Instance_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyInstance_Type" ); - ptr__Int_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyInt_Type" ); - ptr__List_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyList_Type" ); - ptr__Long_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyLong_Type" ); - ptr__Method_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyMethod_Type" ); - ptr__Module_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyModule_Type" ); - ptr__Range_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyRange_Type" ); - ptr__Slice_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PySlice_Type" ); - ptr__String_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyString_Type" ); - ptr__TraceBack_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTraceBack_Type" ); - ptr__Tuple_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyTuple_Type" ); - ptr__Type_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyType_Type" ); - -#if PY_MAJOR_VERSION >= 2 - ptr__Unicode_Type = GetPyTypeObject_As_PyTypeObjectPointer( "PyUnicode_Type" ); -#endif -} - catch( GetAddressException &e ) - { - OutputDebugString( python_dll_name ); - OutputDebugString( " does not contain symbol "); - OutputDebugString( e.name ); - OutputDebugString( "\n" ); - - return false; - } - - return true; -} - -// -// Wrap variables as function calls -// -PyObject * _Exc_ArithmeticError(){ return ptr__Exc_ArithmeticError; } -PyObject * _Exc_AssertionError(){ return ptr__Exc_AssertionError; } -PyObject * _Exc_AttributeError(){ return ptr__Exc_AttributeError; } -PyObject * _Exc_EnvironmentError(){ return ptr__Exc_EnvironmentError; } -PyObject * _Exc_EOFError() { return ptr__Exc_EOFError; } -PyObject * _Exc_Exception() { return ptr__Exc_Exception; } -PyObject * _Exc_FloatingPointError(){ return ptr__Exc_FloatingPointError; } -PyObject * _Exc_ImportError() { return ptr__Exc_ImportError; } -PyObject * _Exc_IndexError() { return ptr__Exc_IndexError; } -PyObject * _Exc_IOError() { return ptr__Exc_IOError; } -PyObject * _Exc_KeyboardInterrupt(){ return ptr__Exc_KeyboardInterrupt; } -PyObject * _Exc_KeyError() { return ptr__Exc_KeyError; } -PyObject * _Exc_LookupError() { return ptr__Exc_LookupError; } -PyObject * _Exc_MemoryError() { return ptr__Exc_MemoryError; } -PyObject * _Exc_MemoryErrorInst(){ return ptr__Exc_MemoryErrorInst; } -PyObject * _Exc_NameError() { return ptr__Exc_NameError; } -PyObject * _Exc_NotImplementedError(){ return ptr__Exc_NotImplementedError; } -PyObject * _Exc_OSError() { return ptr__Exc_OSError; } -PyObject * _Exc_OverflowError() { return ptr__Exc_OverflowError; } -PyObject * _Exc_RuntimeError() { return ptr__Exc_RuntimeError; } -PyObject * _Exc_StandardError() { return ptr__Exc_StandardError; } -PyObject * _Exc_SyntaxError() { return ptr__Exc_SyntaxError; } -PyObject * _Exc_SystemError() { return ptr__Exc_SystemError; } -PyObject * _Exc_SystemExit() { return ptr__Exc_SystemExit; } -PyObject * _Exc_TypeError() { return ptr__Exc_TypeError; } -PyObject * _Exc_ValueError() { return ptr__Exc_ValueError; } -#ifdef MS_WINDOWS -PyObject * _Exc_WindowsError() { return ptr__Exc_WindowsError; } -#endif -PyObject * _Exc_ZeroDivisionError(){ return ptr__Exc_ZeroDivisionError; } - -#if PY_MAJOR_VERSION >= 2 -PyObject * _Exc_IndentationError(){ return ptr__Exc_IndentationError; } -PyObject * _Exc_TabError() { return ptr__Exc_TabError; } -PyObject * _Exc_UnboundLocalError(){ return ptr__Exc_UnboundLocalError; } -PyObject * _Exc_UnicodeError() { return ptr__Exc_UnicodeError; } -#endif - -// -// wrap items in Object.h -// -PyObject * _None() { return ptr__PyNone; } - -PyObject * _False() { return ptr__PyFalse; } -PyObject * _True() { return ptr__PyTrue; } - -PyTypeObject * _Buffer_Type() { return ptr__Buffer_Type; } -PyTypeObject * _CFunction_Type(){ return ptr__CFunction_Type; } -PyTypeObject * _Class_Type() { return ptr__Class_Type; } -PyTypeObject * _CObject_Type() { return ptr__CObject_Type; } -PyTypeObject * _Complex_Type() { return ptr__Complex_Type; } -PyTypeObject * _Dict_Type() { return ptr__Dict_Type; } -PyTypeObject * _File_Type() { return ptr__File_Type; } -PyTypeObject * _Float_Type() { return ptr__Float_Type; } -PyTypeObject * _Function_Type() { return ptr__Function_Type; } -PyTypeObject * _Instance_Type() { return ptr__Instance_Type; } -PyTypeObject * _Bool_Type() { return ptr__Bool_Type; } -PyTypeObject * _Int_Type() { return ptr__Int_Type; } -PyTypeObject * _List_Type() { return ptr__List_Type; } -PyTypeObject * _Long_Type() { return ptr__Long_Type; } -PyTypeObject * _Method_Type() { return ptr__Method_Type; } -PyTypeObject * _Module_Type() { return ptr__Module_Type; } -PyTypeObject * _Range_Type() { return ptr__Range_Type; } -PyTypeObject * _Slice_Type() { return ptr__Slice_Type; } -PyTypeObject * _String_Type() { return ptr__String_Type; } -PyTypeObject * _TraceBack_Type(){ return ptr__TraceBack_Type; } -PyTypeObject * _Tuple_Type() { return ptr__Tuple_Type; } -PyTypeObject * _Type_Type() { return ptr__Type_Type; } - -#if PY_MAJOR_VERSION >= 2 -PyTypeObject * _Unicode_Type() { return ptr__Unicode_Type; } -#endif - -char *__Py_PackageContext() { return *ptr__Py_PackageContext; } - - -// -// wrap the Python Flag variables -// -int &_Py_DebugFlag() { return *ptr_Py_DebugFlag; } -int &_Py_InteractiveFlag() { return *ptr_Py_InteractiveFlag; } -int &_Py_OptimizeFlag() { return *ptr_Py_OptimizeFlag; } -int &_Py_NoSiteFlag() { return *ptr_Py_NoSiteFlag; } -int &_Py_TabcheckFlag() { return *ptr_Py_TabcheckFlag; } -int &_Py_VerboseFlag() { return *ptr_Py_VerboseFlag; } -#if PY_MAJOR_VERSION >= 2 -int &_Py_UnicodeFlag() { return *ptr_Py_UnicodeFlag; } -#endif - -void _XINCREF( PyObject *op ) -{ - // This function must match the contents of Py_XINCREF(op) - if( op == NULL ) - return; - -#ifdef Py_REF_DEBUG - (*ptr_Py_RefTotal)++; -#endif - (op)->ob_refcnt++; - -} - -void _XDECREF( PyObject *op ) -{ - // This function must match the contents of Py_XDECREF(op); - if( op == NULL ) - return; - -#ifdef Py_REF_DEBUG - (*ptr_Py_RefTotal)--; -#endif - - if (--(op)->ob_refcnt == 0) - _Py_Dealloc((PyObject *)(op)); -} - - -#else -#error "Can only delay load under Win32" -#endif - -#else - -// -// Duplicated these declarations from rangeobject.h which is missing the -// extern "C". This has been reported as a bug upto and include 2.1 -// -extern "C" DL_IMPORT(PyTypeObject) PyRange_Type; -extern "C" DL_IMPORT(PyObject *) PyRange_New(long, long, long, int); - - -//================================================================================ -// -// Map onto Macros -// -//================================================================================ - -// -// Wrap variables as function calls -// - -PyObject * _Exc_ArithmeticError() { return ::PyExc_ArithmeticError; } -PyObject * _Exc_AssertionError() { return ::PyExc_AssertionError; } -PyObject * _Exc_AttributeError() { return ::PyExc_AttributeError; } -PyObject * _Exc_EnvironmentError() { return ::PyExc_EnvironmentError; } -PyObject * _Exc_EOFError() { return ::PyExc_EOFError; } -PyObject * _Exc_Exception() { return ::PyExc_Exception; } -PyObject * _Exc_FloatingPointError() { return ::PyExc_FloatingPointError; } -PyObject * _Exc_ImportError() { return ::PyExc_ImportError; } -PyObject * _Exc_IndexError() { return ::PyExc_IndexError; } -PyObject * _Exc_IOError() { return ::PyExc_IOError; } -PyObject * _Exc_KeyboardInterrupt() { return ::PyExc_KeyboardInterrupt; } -PyObject * _Exc_KeyError() { return ::PyExc_KeyError; } -PyObject * _Exc_LookupError() { return ::PyExc_LookupError; } -PyObject * _Exc_MemoryError() { return ::PyExc_MemoryError; } -PyObject * _Exc_MemoryErrorInst() { return ::PyExc_MemoryErrorInst; } -PyObject * _Exc_NameError() { return ::PyExc_NameError; } -PyObject * _Exc_NotImplementedError() { return ::PyExc_NotImplementedError; } -PyObject * _Exc_OSError() { return ::PyExc_OSError; } -PyObject * _Exc_OverflowError() { return ::PyExc_OverflowError; } -PyObject * _Exc_RuntimeError() { return ::PyExc_RuntimeError; } -PyObject * _Exc_StandardError() { return ::PyExc_StandardError; } -PyObject * _Exc_SyntaxError() { return ::PyExc_SyntaxError; } -PyObject * _Exc_SystemError() { return ::PyExc_SystemError; } -PyObject * _Exc_SystemExit() { return ::PyExc_SystemExit; } -PyObject * _Exc_TypeError() { return ::PyExc_TypeError; } -PyObject * _Exc_ValueError() { return ::PyExc_ValueError; } -PyObject * _Exc_ZeroDivisionError() { return ::PyExc_ZeroDivisionError; } - -#ifdef MS_WINDOWS -PyObject * _Exc_WindowsError() { return ::PyExc_WindowsError; } -#endif - - -#if PY_MAJOR_VERSION >= 2 -PyObject * _Exc_IndentationError() { return ::PyExc_IndentationError; } -PyObject * _Exc_TabError() { return ::PyExc_TabError; } -PyObject * _Exc_UnboundLocalError() { return ::PyExc_UnboundLocalError; } -PyObject * _Exc_UnicodeError() { return ::PyExc_UnicodeError; } -#endif - - -// -// wrap items in Object.h -// -PyObject * _None() { return &::_Py_NoneStruct; } - -PyObject * _False() { return Py_False; } -PyObject * _True() { return Py_True; } - -PyTypeObject * _Buffer_Type() { return &PyBuffer_Type; } -PyTypeObject * _CFunction_Type() { return &PyCFunction_Type; } -PyTypeObject * _Class_Type() { return &PyClass_Type; } -PyTypeObject * _CObject_Type() { return &PyCObject_Type; } -PyTypeObject * _Complex_Type() { return &PyComplex_Type; } -PyTypeObject * _Dict_Type() { return &PyDict_Type; } -PyTypeObject * _File_Type() { return &PyFile_Type; } -PyTypeObject * _Float_Type() { return &PyFloat_Type; } -PyTypeObject * _Function_Type() { return &PyFunction_Type; } -PyTypeObject * _Instance_Type() { return &PyInstance_Type; } -PyTypeObject * _Bool_Type() { return &PyBool_Type; } -PyTypeObject * _Int_Type() { return &PyInt_Type; } -PyTypeObject * _List_Type() { return &PyList_Type; } -PyTypeObject * _Long_Type() { return &PyLong_Type; } -PyTypeObject * _Method_Type() { return &PyMethod_Type; } -PyTypeObject * _Module_Type() { return &PyModule_Type; } -PyTypeObject * _Range_Type() { return &PyRange_Type; } -PyTypeObject * _Slice_Type() { return &PySlice_Type; } -PyTypeObject * _String_Type() { return &PyString_Type; } -PyTypeObject * _TraceBack_Type() { return &PyTraceBack_Type; } -PyTypeObject * _Tuple_Type() { return &PyTuple_Type; } -PyTypeObject * _Type_Type() { return &PyType_Type; } - -#if PY_MAJOR_VERSION >= 2 -PyTypeObject * _Unicode_Type() { return &PyUnicode_Type; } -#endif - -// -// wrap flags -// -int &_Py_DebugFlag() { return Py_DebugFlag; } -int &_Py_InteractiveFlag(){ return Py_InteractiveFlag; } -int &_Py_OptimizeFlag() { return Py_OptimizeFlag; } -int &_Py_NoSiteFlag() { return Py_NoSiteFlag; } -int &_Py_TabcheckFlag() { return Py_TabcheckFlag; } -int &_Py_VerboseFlag() { return Py_VerboseFlag; } -#if PY_MAJOR_VERSION >= 2 -int &_Py_UnicodeFlag() { return Py_UnicodeFlag; } -#endif -char *__Py_PackageContext(){ return _Py_PackageContext; } - -// -// Needed to keep the abstactions for delayload interface -// -void _XINCREF( PyObject *op ) -{ - Py_XINCREF(op); -} - -void _XDECREF( PyObject *op ) -{ - Py_XDECREF(op); -} - -#endif -} diff --git a/src/CXX/Python2/IndirectPythonInterface.hxx b/src/CXX/Python2/IndirectPythonInterface.hxx index 6c4e4f0da..a29a394c6 100644 --- a/src/CXX/Python2/IndirectPythonInterface.hxx +++ b/src/CXX/Python2/IndirectPythonInterface.hxx @@ -39,7 +39,6 @@ #define __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ #include "CXX/WrapPython.h" -#include "CXX/Config.hxx" namespace Py { @@ -48,152 +47,152 @@ bool InitialisePythonIndirectInterface(); // // Wrap Exception variables as function calls // -PYCXX_EXPORT PyObject * _Exc_Exception(); -PYCXX_EXPORT PyObject * _Exc_StandardError(); -PYCXX_EXPORT PyObject * _Exc_ArithmeticError(); -PYCXX_EXPORT PyObject * _Exc_LookupError(); +PyObject * _Exc_Exception(); +PyObject * _Exc_StandardError(); +PyObject * _Exc_ArithmeticError(); +PyObject * _Exc_LookupError(); -PYCXX_EXPORT PyObject * _Exc_AssertionError(); -PYCXX_EXPORT PyObject * _Exc_AttributeError(); -PYCXX_EXPORT PyObject * _Exc_EOFError(); -PYCXX_EXPORT PyObject * _Exc_FloatingPointError(); -PYCXX_EXPORT PyObject * _Exc_EnvironmentError(); -PYCXX_EXPORT PyObject * _Exc_IOError(); -PYCXX_EXPORT PyObject * _Exc_OSError(); -PYCXX_EXPORT PyObject * _Exc_ImportError(); -PYCXX_EXPORT PyObject * _Exc_IndexError(); -PYCXX_EXPORT PyObject * _Exc_KeyError(); -PYCXX_EXPORT PyObject * _Exc_KeyboardInterrupt(); -PYCXX_EXPORT PyObject * _Exc_MemoryError(); -PYCXX_EXPORT PyObject * _Exc_NameError(); -PYCXX_EXPORT PyObject * _Exc_OverflowError(); -PYCXX_EXPORT PyObject * _Exc_RuntimeError(); -PYCXX_EXPORT PyObject * _Exc_NotImplementedError(); -PYCXX_EXPORT PyObject * _Exc_SyntaxError(); -PYCXX_EXPORT PyObject * _Exc_SystemError(); -PYCXX_EXPORT PyObject * _Exc_SystemExit(); -PYCXX_EXPORT PyObject * _Exc_TypeError(); -PYCXX_EXPORT PyObject * _Exc_ValueError(); -PYCXX_EXPORT PyObject * _Exc_ZeroDivisionError(); +PyObject * _Exc_AssertionError(); +PyObject * _Exc_AttributeError(); +PyObject * _Exc_EOFError(); +PyObject * _Exc_FloatingPointError(); +PyObject * _Exc_EnvironmentError(); +PyObject * _Exc_IOError(); +PyObject * _Exc_OSError(); +PyObject * _Exc_ImportError(); +PyObject * _Exc_IndexError(); +PyObject * _Exc_KeyError(); +PyObject * _Exc_KeyboardInterrupt(); +PyObject * _Exc_MemoryError(); +PyObject * _Exc_NameError(); +PyObject * _Exc_OverflowError(); +PyObject * _Exc_RuntimeError(); +PyObject * _Exc_NotImplementedError(); +PyObject * _Exc_SyntaxError(); +PyObject * _Exc_SystemError(); +PyObject * _Exc_SystemExit(); +PyObject * _Exc_TypeError(); +PyObject * _Exc_ValueError(); +PyObject * _Exc_ZeroDivisionError(); #ifdef MS_WINDOWS -PYCXX_EXPORT PyObject * _Exc_WindowsError(); +PyObject * _Exc_WindowsError(); #endif -PYCXX_EXPORT PyObject * _Exc_MemoryErrorInst(); +PyObject * _Exc_MemoryErrorInst(); #if PY_MAJOR_VERSION >= 2 -PYCXX_EXPORT PyObject * _Exc_IndentationError(); -PYCXX_EXPORT PyObject * _Exc_TabError(); -PYCXX_EXPORT PyObject * _Exc_UnboundLocalError(); -PYCXX_EXPORT PyObject * _Exc_UnicodeError(); +PyObject * _Exc_IndentationError(); +PyObject * _Exc_TabError(); +PyObject * _Exc_UnboundLocalError(); +PyObject * _Exc_UnicodeError(); #endif // // Wrap Object variables as function calls // -PYCXX_EXPORT PyObject * _None(); +PyObject * _None(); -PYCXX_EXPORT PyObject * _False(); -PYCXX_EXPORT PyObject * _True(); +PyObject * _False(); +PyObject * _True(); // // Wrap Type variables as function calls // -PYCXX_EXPORT PyTypeObject * _List_Type(); -PYCXX_EXPORT bool _List_Check( PyObject *o ); +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *o ); -PYCXX_EXPORT PyTypeObject * _Buffer_Type(); -PYCXX_EXPORT bool _Buffer_Check( PyObject *op ); +PyTypeObject * _Buffer_Type(); +bool _Buffer_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Class_Type(); -PYCXX_EXPORT bool _Class_Check( PyObject *op ); +PyTypeObject * _Class_Type(); +bool _Class_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Instance_Type(); -PYCXX_EXPORT bool _Instance_Check( PyObject *op ); +PyTypeObject * _Instance_Type(); +bool _Instance_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Method_Type(); -PYCXX_EXPORT bool _Method_Check( PyObject *op ); +PyTypeObject * _Method_Type(); +bool _Method_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _CObject_Type(); -PYCXX_EXPORT bool _CObject_Check( PyObject *op ); +PyTypeObject * _CObject_Type(); +bool _CObject_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Complex_Type(); -PYCXX_EXPORT bool _Complex_Check( PyObject *op ); +PyTypeObject * _Complex_Type(); +bool _Complex_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Dict_Type(); -PYCXX_EXPORT bool _Dict_Check( PyObject *op ); +PyTypeObject * _Dict_Type(); +bool _Dict_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _File_Type(); -PYCXX_EXPORT bool _File_Check( PyObject *op ); +PyTypeObject * _File_Type(); +bool _File_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Float_Type(); -PYCXX_EXPORT bool _Float_Check( PyObject *op ); +PyTypeObject * _Float_Type(); +bool _Float_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Frame_Type(); -PYCXX_EXPORT bool _Frame_Check( PyObject *op ); +PyTypeObject * _Frame_Type(); +bool _Frame_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Function_Type(); -PYCXX_EXPORT bool _Function_Check( PyObject *op ); +PyTypeObject * _Function_Type(); +bool _Function_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Bool_Type(); -PYCXX_EXPORT bool _Boolean_Check( PyObject *op ); +PyTypeObject * _Bool_Type(); +bool _Boolean_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Int_Type(); -PYCXX_EXPORT bool _Int_Check( PyObject *op ); +PyTypeObject * _Int_Type(); +bool _Int_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _List_Type(); -PYCXX_EXPORT bool _List_Check( PyObject *op ); +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Long_Type(); -PYCXX_EXPORT bool _Long_Check( PyObject *op ); +PyTypeObject * _Long_Type(); +bool _Long_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _CFunction_Type(); -PYCXX_EXPORT bool _CFunction_Check( PyObject *op ); +PyTypeObject * _CFunction_Type(); +bool _CFunction_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Module_Type(); -PYCXX_EXPORT bool _Module_Check( PyObject *op ); +PyTypeObject * _Module_Type(); +bool _Module_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Type_Type(); -PYCXX_EXPORT bool _Type_Check( PyObject *op ); +PyTypeObject * _Type_Type(); +bool _Type_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Range_Type(); -PYCXX_EXPORT bool _Range_Check( PyObject *op ); +PyTypeObject * _Range_Type(); +bool _Range_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Slice_Type(); -PYCXX_EXPORT bool _Slice_Check( PyObject *op ); +PyTypeObject * _Slice_Type(); +bool _Slice_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _String_Type(); -PYCXX_EXPORT bool _String_Check( PyObject *op ); +PyTypeObject * _String_Type(); +bool _String_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _Unicode_Type(); -PYCXX_EXPORT bool _Unicode_Check( PyObject *op ); +PyTypeObject * _Unicode_Type(); +bool _Unicode_Check( PyObject *op ); -PYCXX_EXPORT PyTypeObject * _TraceBack_Type(); -PYCXX_EXPORT bool _TraceBack_Check( PyObject *v ); +PyTypeObject * _TraceBack_Type(); +bool _TraceBack_Check( PyObject *v ); -PYCXX_EXPORT PyTypeObject * _Tuple_Type(); -PYCXX_EXPORT bool _Tuple_Check( PyObject *op ); +PyTypeObject * _Tuple_Type(); +bool _Tuple_Check( PyObject *op ); #if PY_MAJOR_VERSION >= 2 -PYCXX_EXPORT PyTypeObject * _Unicode_Type(); -PYCXX_EXPORT bool _Unicode_Check( PyObject *op ); +PyTypeObject * _Unicode_Type(); +bool _Unicode_Check( PyObject *op ); #endif -PYCXX_EXPORT int &_Py_DebugFlag(); -PYCXX_EXPORT int &_Py_InteractiveFlag(); -PYCXX_EXPORT int &_Py_OptimizeFlag(); -PYCXX_EXPORT int &_Py_NoSiteFlag(); -PYCXX_EXPORT int &_Py_TabcheckFlag(); -PYCXX_EXPORT int &_Py_VerboseFlag(); +int &_Py_DebugFlag(); +int &_Py_InteractiveFlag(); +int &_Py_OptimizeFlag(); +int &_Py_NoSiteFlag(); +int &_Py_TabcheckFlag(); +int &_Py_VerboseFlag(); #if PY_MAJOR_VERSION >= 2 -PYCXX_EXPORT int &_Py_UnicodeFlag(); +int &_Py_UnicodeFlag(); #endif -PYCXX_EXPORT void _XINCREF( PyObject *op ); -PYCXX_EXPORT void _XDECREF( PyObject *op ); +void _XINCREF( PyObject *op ); +void _XDECREF( PyObject *op ); -PYCXX_EXPORT char *__Py_PackageContext(); +char *__Py_PackageContext(); } #endif // __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ diff --git a/src/CXX/Python2/Objects.hxx b/src/CXX/Python2/Objects.hxx index ea9833c44..286293ead 100644 --- a/src/CXX/Python2/Objects.hxx +++ b/src/CXX/Python2/Objects.hxx @@ -52,7 +52,7 @@ namespace Py { - typedef size_t sequence_index_type; // type of an index into a sequence + typedef int sequence_index_type; // type of an index into a sequence // Forward declarations class Object; @@ -141,7 +141,7 @@ namespace Py // which you can use in accepts when writing a wrapper class. // See Demo/range.h and Demo/range.cxx for an example. - class PYCXX_EXPORT Object + class Object { private: // the pointer to the Python object @@ -469,11 +469,11 @@ namespace Py // TMM: 31May'01 - Added the #ifndef so I can exlude iostreams. #ifndef CXX_NO_IOSTREAMS - PYCXX_EXPORT std::ostream& operator<< (std::ostream& os, const Object& ob); + std::ostream& operator<< (std::ostream& os, const Object& ob); #endif // Class Type - class PYCXX_EXPORT Type: public Object + class Type: public Object { public: explicit Type (PyObject* pyob, bool owned = false): Object(pyob, owned) @@ -519,7 +519,7 @@ namespace Py // =============================================== // class boolean - class PYCXX_EXPORT Boolean: public Object + class Boolean: public Object { public: // Constructor @@ -582,7 +582,7 @@ namespace Py // =============================================== // class Int - class PYCXX_EXPORT Int: public Object + class Int: public Object { public: // Constructor @@ -695,7 +695,7 @@ namespace Py // =============================================== // class Long - class PYCXX_EXPORT Long: public Object + class Long: public Object { public: // Constructor @@ -798,7 +798,7 @@ namespace Py #ifdef HAVE_LONG_LONG // =============================================== // class LongLong - class PYCXX_EXPORT LongLong: public Object + class LongLong: public Object { public: // Constructor @@ -927,7 +927,7 @@ namespace Py // =============================================== // class Float // - class PYCXX_EXPORT Float: public Object + class Float: public Object { public: // Constructor @@ -1004,7 +1004,7 @@ namespace Py // =============================================== // class Complex - class PYCXX_EXPORT Complex: public Object + class Complex: public Object { public: // Constructor @@ -1115,7 +1115,7 @@ namespace Py { protected: SeqBase& s; // the sequence - size_t offset; // item number + int offset; // item number T the_item; // lvalue public: @@ -1130,7 +1130,7 @@ namespace Py // TMM: added this seqref ctor for use with STL algorithms seqref (Object& obj) : s(dynamic_cast< SeqBase&>(obj)) - , offset( 0 ) + , offset( NULL ) , the_item(s.getItem(offset)) {} ~seqref() @@ -1449,7 +1449,7 @@ namespace Py protected: friend class SeqBase; SeqBase* seq; - size_type count; + int count; public: ~iterator () @@ -1460,7 +1460,7 @@ namespace Py , count( 0 ) {} - iterator (SeqBase* s, size_type where) + iterator (SeqBase* s, int where) : seq( s ) , count( where ) {} @@ -1587,7 +1587,7 @@ namespace Py sequence_index_type count; private: - const_iterator (const SeqBase* s, size_type where) + const_iterator (const SeqBase* s, int where) : seq( s ) , count( where ) {} @@ -1724,19 +1724,19 @@ namespace Py template bool operator<=(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); template bool operator>=(const EXPLICIT_TYPENAME SeqBase::const_iterator& left, const EXPLICIT_TYPENAME SeqBase::const_iterator& right); - PYCXX_EXPORT extern bool operator==(const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator!=(const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator< (const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator> (const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator<=(const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator>=(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator==(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator!=(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator< (const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator> (const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator<=(const Sequence::iterator& left, const Sequence::iterator& right); + extern bool operator>=(const Sequence::iterator& left, const Sequence::iterator& right); - PYCXX_EXPORT extern bool operator==(const Sequence::const_iterator& left, const Sequence::const_iterator& right); - PYCXX_EXPORT extern bool operator!=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); - PYCXX_EXPORT extern bool operator< (const Sequence::const_iterator& left, const Sequence::const_iterator& right); - PYCXX_EXPORT extern bool operator> (const Sequence::const_iterator& left, const Sequence::const_iterator& right); - PYCXX_EXPORT extern bool operator<=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); - PYCXX_EXPORT extern bool operator>=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator==(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator!=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator< (const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator> (const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator<=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); + extern bool operator>=(const Sequence::const_iterator& left, const Sequence::const_iterator& right); // ================================================== // class Char @@ -1746,7 +1746,7 @@ namespace Py typedef std::basic_string unicodestring; extern Py_UNICODE unicode_null_string[1]; - class PYCXX_EXPORT Char: public Object + class Char: public Object { public: explicit Char (PyObject *pyob, bool owned = false): Object(pyob, owned) @@ -1833,7 +1833,7 @@ namespace Py // String and Bytes compatible with Python3 version in 6.0.0 PyCXX class Bytes; - class PYCXX_EXPORT String: public SeqBase + class String: public SeqBase { public: virtual size_type capacity() const @@ -1889,13 +1889,6 @@ namespace Py validate(); } - String( const std::string &v, std::string::size_type vsize ) - : SeqBase(PyString_FromStringAndSize( const_cast(v.data()), - static_cast( vsize ) ), true) - { - validate(); - } - String( const char *v, int vsize ) : SeqBase(PyString_FromStringAndSize( const_cast(v), vsize ), true ) { @@ -1989,7 +1982,7 @@ namespace Py } } }; - class PYCXX_EXPORT Bytes: public SeqBase + class Bytes: public SeqBase { public: virtual size_type capacity() const @@ -2019,12 +2012,6 @@ namespace Py validate(); } - Bytes( const std::string& v, std::string::size_type vsize ) - : SeqBase(PyString_FromStringAndSize( const_cast(v.data()), static_cast( vsize ) ), true) - { - validate(); - } - Bytes( const char *v, int vsize ) : SeqBase(PyString_FromStringAndSize( const_cast(v), vsize ), true ) { @@ -2072,7 +2059,7 @@ namespace Py String decode( const char *encoding, const char *error="strict" ) { - return Object( PyString_AsDecodedObject( ptr(), encoding, error ) ); + return Object( PyString_AsDecodedObject( ptr(), encoding, error ), true ); } // Queries @@ -2121,7 +2108,7 @@ namespace Py #else // original PyCXX 5.4.x version of String - class PYCXX_EXPORT String: public SeqBase + class String: public SeqBase { public: virtual size_type capacity() const @@ -2170,13 +2157,6 @@ namespace Py validate(); } - String( const std::string& v, std::string::size_type vsize ) - : SeqBase(PyString_FromStringAndSize( const_cast(v.data()), - static_cast( vsize ) ), true) - { - validate(); - } - String( const char *v, int vsize ) : SeqBase(PyString_FromStringAndSize( const_cast(v), vsize ), true ) { @@ -2228,17 +2208,17 @@ namespace Py { if( isUnicode() ) { - return String( PyUnicode_AsEncodedString( ptr(), encoding, error ) ); + return String( PyUnicode_AsEncodedString( ptr(), encoding, error ), true ); } else { - return String( PyString_AsEncodedObject( ptr(), encoding, error ) ); + return String( PyString_AsEncodedObject( ptr(), encoding, error ), true ); } } String decode( const char *encoding, const char *error="strict" ) { - return Object( PyString_AsDecodedObject( ptr(), encoding, error ) ); + return Object( PyString_AsDecodedObject( ptr(), encoding, error ), true ); } // Queries @@ -2290,7 +2270,7 @@ namespace Py // ================================================== // class Tuple - class PYCXX_EXPORT Tuple: public Sequence + class Tuple: public Sequence { public: virtual void setItem (sequence_index_type offset, const Object&ob) @@ -2314,7 +2294,7 @@ namespace Py } // New tuple of a given size - explicit Tuple (sequence_index_type size = 0) + explicit Tuple (int size = 0) { set(PyTuple_New (size), true); validate (); @@ -2368,11 +2348,11 @@ namespace Py }; - class PYCXX_EXPORT TupleN: public Tuple + class TupleN: public Tuple { public: TupleN() - : Tuple( (sequence_index_type)0 ) + : Tuple( 0 ) { } @@ -2483,7 +2463,7 @@ namespace Py // ================================================== // class List - class PYCXX_EXPORT List: public Sequence + class List: public Sequence { public: // Constructor @@ -2496,7 +2476,7 @@ namespace Py validate(); } // Creation at a fixed size - List (sequence_index_type size = 0) + List (int size = 0) { set(PyList_New (size), true); validate(); @@ -2512,7 +2492,7 @@ namespace Py // List from a sequence List (const Sequence& s): Sequence() { - sequence_index_type n = s.length(); + int n = (int)s.length(); set(PyList_New (n), true); validate(); for (sequence_index_type i=0; i < n; i++) @@ -2858,7 +2838,7 @@ namespace Py return mapref(*this, key); } - size_type length () const + int length () const { return PyMapping_Length (ptr()); } @@ -2956,7 +2936,7 @@ namespace Py // MapBase* map; List keys; // for iterating over the map - size_type pos; // index into the keys + int pos; // index into the keys private: iterator( MapBase* m, List k, int p ) @@ -3059,7 +3039,7 @@ namespace Py friend class MapBase; const MapBase* map; List keys; // for iterating over the map - size_type pos; // index into the keys + int pos; // index into the keys private: const_iterator( const MapBase* m, List k, int p ) @@ -3148,15 +3128,15 @@ namespace Py template bool operator==(const EXPLICIT_TYPENAME MapBase::const_iterator& left, const EXPLICIT_TYPENAME MapBase::const_iterator& right); template bool operator!=(const EXPLICIT_TYPENAME MapBase::const_iterator& left, const EXPLICIT_TYPENAME MapBase::const_iterator& right); - PYCXX_EXPORT extern bool operator==(const Mapping::iterator& left, const Mapping::iterator& right); - PYCXX_EXPORT extern bool operator!=(const Mapping::iterator& left, const Mapping::iterator& right); - PYCXX_EXPORT extern bool operator==(const Mapping::const_iterator& left, const Mapping::const_iterator& right); - PYCXX_EXPORT extern bool operator!=(const Mapping::const_iterator& left, const Mapping::const_iterator& right); + extern bool operator==(const Mapping::iterator& left, const Mapping::iterator& right); + extern bool operator!=(const Mapping::iterator& left, const Mapping::iterator& right); + extern bool operator==(const Mapping::const_iterator& left, const Mapping::const_iterator& right); + extern bool operator!=(const Mapping::const_iterator& left, const Mapping::const_iterator& right); // ================================================== // class Dict - class PYCXX_EXPORT Dict: public Mapping + class Dict: public Mapping { public: // Constructor @@ -3194,7 +3174,7 @@ namespace Py } }; - class PYCXX_EXPORT Callable: public Object + class Callable: public Object { public: // Constructor @@ -3247,7 +3227,7 @@ namespace Py } }; - class PYCXX_EXPORT Module: public Object + class Module: public Object { public: explicit Module (PyObject* pyob, bool owned = false): Object (pyob, owned) @@ -3292,7 +3272,7 @@ namespace Py inline Object Object::callMemberFunction( const std::string &function_name ) const { Callable target( getAttr( function_name ) ); - Tuple args( (sequence_index_type)0 ); + Tuple args( 0 ); return target.apply( args ); } diff --git a/src/CXX/Python2/PythonType.hxx b/src/CXX/Python2/PythonType.hxx index 0faa3378c..fc45a4bc6 100644 --- a/src/CXX/Python2/PythonType.hxx +++ b/src/CXX/Python2/PythonType.hxx @@ -40,7 +40,7 @@ namespace Py { - class PYCXX_EXPORT PythonType + class PythonType { public: // if you define one sequence method you must define @@ -57,17 +57,15 @@ namespace Py PythonType &doc( const char *d ); PythonType &supportClass( void ); -#if !defined( PY3 ) PythonType &dealloc( void (*f)( PyObject* ) ); -#endif -#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 ) +#if defined( PYCXX_PYTHON_2TO3 ) PythonType &supportPrint( void ); #endif PythonType &supportGetattr( void ); PythonType &supportSetattr( void ); PythonType &supportGetattro( void ); PythonType &supportSetattro( void ); -#if defined( PYCXX_PYTHON_2TO3 ) || !defined( PY3 ) +#if defined( PYCXX_PYTHON_2TO3 ) PythonType &supportCompare( void ); #endif PythonType &supportRichCompare( void ); diff --git a/src/CXX/Python2/cxx_extensions.cxx b/src/CXX/Python2/cxx_extensions.cxx index 8615c2daf..611a335d1 100644 --- a/src/CXX/Python2/cxx_extensions.cxx +++ b/src/CXX/Python2/cxx_extensions.cxx @@ -254,12 +254,16 @@ extern "C" // All the following functions redirect the call from Python // onto the matching virtual function in PythonExtensionBase // +#if defined( PYCXX_PYTHON_2TO3 ) static int print_handler( PyObject *, FILE *, int ); +#endif static PyObject *getattr_handler( PyObject *, char * ); static int setattr_handler( PyObject *, char *, PyObject * ); static PyObject *getattro_handler( PyObject *, PyObject * ); static int setattro_handler( PyObject *, PyObject *, PyObject * ); +#if defined( PYCXX_PYTHON_2TO3 ) static int compare_handler( PyObject *, PyObject * ); +#endif static PyObject *rich_compare_handler( PyObject *, PyObject *, int ); static PyObject *repr_handler( PyObject * ); static PyObject *str_handler( PyObject * ); @@ -290,9 +294,7 @@ extern "C" static PyObject *number_invert_handler( PyObject * ); static PyObject *number_int_handler( PyObject * ); static PyObject *number_float_handler( PyObject * ); -#if !defined( PY3 ) static PyObject *number_long_handler( PyObject * ); -#endif static PyObject *number_oct_handler( PyObject * ); static PyObject *number_hex_handler( PyObject * ); static PyObject *number_add_handler( PyObject *, PyObject * ); @@ -335,13 +337,9 @@ PythonType &PythonType::supportSequenceType() sequence_table->sq_concat = sequence_concat_handler; sequence_table->sq_repeat = sequence_repeat_handler; sequence_table->sq_item = sequence_item_handler; -#if !defined( PY3 ) sequence_table->sq_slice = sequence_slice_handler; -#endif sequence_table->sq_ass_item = sequence_ass_item_handler; // BAS setup seperately? -#if !defined( PY3 ) sequence_table->sq_ass_slice = sequence_ass_slice_handler; // BAS setup seperately? -#endif } return *this; } @@ -370,36 +368,26 @@ PythonType &PythonType::supportNumberType() number_table->nb_add = number_add_handler; number_table->nb_subtract = number_subtract_handler; number_table->nb_multiply = number_multiply_handler; -#if !defined( PY3 ) number_table->nb_divide = number_divide_handler; -#endif number_table->nb_remainder = number_remainder_handler; number_table->nb_divmod = number_divmod_handler; number_table->nb_power = number_power_handler; number_table->nb_negative = number_negative_handler; number_table->nb_positive = number_positive_handler; number_table->nb_absolute = number_absolute_handler; -#if !defined( PY3 ) number_table->nb_nonzero = number_nonzero_handler; -#endif number_table->nb_invert = number_invert_handler; number_table->nb_lshift = number_lshift_handler; number_table->nb_rshift = number_rshift_handler; number_table->nb_and = number_and_handler; number_table->nb_xor = number_xor_handler; number_table->nb_or = number_or_handler; -#if !defined( PY3 ) number_table->nb_coerce = 0; -#endif number_table->nb_int = number_int_handler; -#if !defined( PY3 ) number_table->nb_long = number_long_handler; -#endif number_table->nb_float = number_float_handler; -#if !defined( PY3 ) number_table->nb_oct = number_oct_handler; number_table->nb_hex = number_hex_handler; -#endif } return *this; } @@ -411,11 +399,9 @@ PythonType &PythonType::supportBufferType() buffer_table = new PyBufferProcs; memset( buffer_table, 0, sizeof( PyBufferProcs ) ); // ensure new fields are 0 table->tp_as_buffer = buffer_table; -#if !defined( PY3 ) buffer_table->bf_getreadbuffer = buffer_getreadbuffer_handler; buffer_table->bf_getwritebuffer = buffer_getwritebuffer_handler; buffer_table->bf_getsegcount = buffer_getsegcount_handler; -#endif } return *this; } @@ -434,10 +420,9 @@ PythonType::PythonType( size_t basic_size, int itemsize, const char *default_nam memset( table, 0, sizeof( PyTypeObject ) ); // ensure new fields are 0 *reinterpret_cast( table ) = py_object_initializer; -#if !defined( PY3 ) table->ob_type = _Type_Type(); table->ob_size = 0; -#endif + table->tp_name = const_cast( default_name ); table->tp_basicsize = basic_size; table->tp_itemsize = itemsize; @@ -575,11 +560,13 @@ PythonType &PythonType::dealloc( void( *f )( PyObject * )) return *this; } +#if defined( PYCXX_PYTHON_2TO3 ) PythonType &PythonType::supportPrint() { table->tp_print = print_handler; return *this; } +#endif PythonType &PythonType::supportGetattr() { @@ -605,11 +592,13 @@ PythonType &PythonType::supportSetattro() return *this; } +#if defined( PYCXX_PYTHON_2TO3 ) PythonType &PythonType::supportCompare() { table->tp_compare = compare_handler; return *this; } +#endif #if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 1) PythonType &PythonType::supportRichCompare() @@ -669,6 +658,7 @@ PythonExtensionBase *getPythonExtensionBase( PyObject *self ) } +#if defined( PYCXX_PYTHON_2TO3 ) extern "C" int print_handler( PyObject *self, FILE *fp, int flags ) { try @@ -681,6 +671,7 @@ extern "C" int print_handler( PyObject *self, FILE *fp, int flags ) return -1; // indicate error } } +#endif extern "C" PyObject *getattr_handler( PyObject *self, char *name ) { @@ -734,6 +725,7 @@ extern "C" int setattro_handler( PyObject *self, PyObject *name, PyObject *value } } +#if defined( PYCXX_PYTHON_2TO3 ) extern "C" int compare_handler( PyObject *self, PyObject *other ) { try @@ -746,6 +738,7 @@ extern "C" int compare_handler( PyObject *self, PyObject *other ) return -1; // indicate error } } +#endif #if PY_MAJOR_VERSION > 2 || (PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION >= 1) extern "C" PyObject *rich_compare_handler( PyObject *self, PyObject *other, int op ) @@ -1766,61 +1759,6 @@ extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple } } -extern "C" PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ) -{ - try - { - Tuple self_and_name_tuple( _self_and_name_tuple ); - - PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); - void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject ); - if( self_as_void == NULL ) - return NULL; - - ExtensionModuleBase *self = static_cast( self_as_void ); - - Object result - ( - self->invoke_method_noargs - ( - PyCObject_AsVoidPtr( self_and_name_tuple[1].ptr() ) - ) - ); - - return new_reference_to( result.ptr() ); - } - catch( Exception & ) - { - return 0; - } -#if 0 - try - { - Tuple self_and_name_tuple( _self_and_name_tuple ); - - PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); - void *self_as_void = PyCObject_AsVoidPtr( self_in_cobject ); - if( self_as_void == NULL ) - return NULL; - - ExtensionModuleBase *self = static_cast( self_as_void ); - - String py_name( self_and_name_tuple[1] ); - std::string name( py_name.as_std_string( NULL ) ); - - Object result( self->invoke_method_noargs( name ) ); - - return new_reference_to( result.ptr() ); - } - catch( Exception & ) - { - return 0; - } -#else - return 0; -#endif -} - extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ) { try diff --git a/src/CXX/Python3/Config.hxx b/src/CXX/Python3/Config.hxx new file mode 100644 index 000000000..10c611fb5 --- /dev/null +++ b/src/CXX/Python3/Config.hxx @@ -0,0 +1,117 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __PyCXX_config_hh__ +#define __PyCXX_config_hh__ + +// +// Microsoft VC++ 6.0 has no traits +// +#if defined( _MSC_VER ) + +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 + +#elif defined( __GNUC__ ) +# if __GNUC__ >= 3 +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 +# else +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 0 +#endif + +// +// Assume all other compilers do +// +#else + +// Macros to deal with deficiencies in compilers +# define STANDARD_LIBRARY_HAS_ITERATOR_TRAITS 1 +#endif + +#if STANDARD_LIBRARY_HAS_ITERATOR_TRAITS +# define random_access_iterator_parent(itemtype) std::iterator +#else +# define random_access_iterator_parent(itemtype) std::random_access_iterator +#endif + +// +// Which C++ standard is in use? +// +#if defined( _MSC_VER ) +# if _MSC_VER <= 1200 +// MSVC++ 6.0 +# define PYCXX_ISO_CPP_LIB 0 +# define STR_STREAM +# define TEMPLATE_TYPENAME class +# else +# define PYCXX_ISO_CPP_LIB 1 +# define STR_STREAM +# define TEMPLATE_TYPENAME typename +# endif +#elif defined( __GNUC__ ) +# if __GNUC__ >= 3 +# define PYCXX_ISO_CPP_LIB 1 +# define STR_STREAM +# define TEMPLATE_TYPENAME typename +# else +# define PYCXX_ISO_CPP_LIB 0 +# define STR_STREAM +# define TEMPLATE_TYPENAME class +# endif +#endif + +#if PYCXX_ISO_CPP_LIB +# define STR_STREAM +# define OSTRSTREAM ostringstream +# define EXPLICIT_TYPENAME typename +# define EXPLICIT_CLASS class +# define TEMPLATE_TYPENAME typename +#else +# define STR_STREAM +# define OSTRSTREAM ostrstream +# define EXPLICIT_TYPENAME +# define EXPLICIT_CLASS +# define TEMPLATE_TYPENAME class +#endif + +// before 3.2 Py_hash_t was missing +#ifndef PY_MAJOR_VERSION +#error not defined PY_MAJOR_VERSION +#endif +#if PY_MINOR_VERSION < 2 +typedef long int Py_hash_t; +#endif +#endif // __PyCXX_config_hh__ diff --git a/src/CXX/Python3/CxxDebug.hxx b/src/CXX/Python3/CxxDebug.hxx new file mode 100644 index 000000000..b646ffdd9 --- /dev/null +++ b/src/CXX/Python3/CxxDebug.hxx @@ -0,0 +1,17 @@ +// +// CxxDebug.hxx +// +// Copyright (c) 2008 Barry A. Scott +// +#ifndef __CXX_Debug_hxx +#define __CXX_Debug_hxx + +// +// Functions useful when debugging PyCXX +// +#ifdef PYCXX_DEBUG +extern void bpt(); +extern void printRefCount( PyObject *obj ); +#endif + +#endif diff --git a/src/CXX/Python3/Exception.hxx b/src/CXX/Python3/Exception.hxx new file mode 100644 index 000000000..0bd052d5c --- /dev/null +++ b/src/CXX/Python3/Exception.hxx @@ -0,0 +1,260 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Exception_h +#define __CXX_Exception_h + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Python3/Config.hxx" +#include "CXX/Python3/CxxDebug.hxx" +#include "CXX/Python3/IndirectPythonInterface.hxx" + +#include +#include + +// This mimics the Python structure, in order to minimize confusion +namespace Py +{ + class ExtensionExceptionType; + + class Object; + + class Exception + { + public: + Exception( ExtensionExceptionType &exception, const std::string &reason ); + Exception( ExtensionExceptionType &exception, Object &reason ); + + explicit Exception () + {} + + Exception (const std::string &reason) + { + PyErr_SetString( Py::_Exc_RuntimeError(), reason.c_str() ); + } + + Exception( PyObject *exception, const std::string &reason ) + { + PyErr_SetString( exception, reason.c_str() ); + } + + Exception( PyObject *exception, Object &reason ); + + void clear() // clear the error + // technically but not philosophically const + { + PyErr_Clear(); + } + }; + + + // Abstract + class StandardError: public Exception + { + protected: + explicit StandardError() + {} + }; + + class LookupError: public StandardError + { + protected: + explicit LookupError() + {} + }; + + class ArithmeticError: public StandardError + { + protected: + explicit ArithmeticError() + {} + }; + + class EnvironmentError: public StandardError + { + protected: + explicit EnvironmentError() + {} + }; + + // Concrete + + class TypeError: public StandardError + { + public: + TypeError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_TypeError(),reason.c_str() ); + } + }; + + class IndexError: public LookupError + { + public: + IndexError (const std::string& reason) + : LookupError() + { + PyErr_SetString( Py::_Exc_IndexError(), reason.c_str() ); + } + }; + + class AttributeError: public StandardError + { + public: + AttributeError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_AttributeError(), reason.c_str() ); + } + }; + + class NameError: public StandardError + { + public: + NameError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_NameError(), reason.c_str() ); + } + }; + + class RuntimeError: public StandardError + { + public: + RuntimeError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_RuntimeError(), reason.c_str() ); + } + }; + + class NotImplementedError: public StandardError + { + public: + NotImplementedError (const std::string& reason) + : StandardError() + { + PyErr_SetString (Py::_Exc_NotImplementedError(), reason.c_str()); + } + }; + + class SystemError: public StandardError + { + public: + SystemError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_SystemError(),reason.c_str() ); + } + }; + + class KeyError: public LookupError + { + public: + KeyError (const std::string& reason) + : LookupError() + { + PyErr_SetString( Py::_Exc_KeyError(),reason.c_str() ); + } + }; + + + class ValueError: public StandardError + { + public: + ValueError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_ValueError(), reason.c_str() ); + } + }; + + class OverflowError: public ArithmeticError + { + public: + OverflowError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString( Py::_Exc_OverflowError(), reason.c_str() ); + } + }; + + class ZeroDivisionError: public ArithmeticError + { + public: + ZeroDivisionError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString( Py::_Exc_ZeroDivisionError(), reason.c_str() ); + } + }; + + class FloatingPointError: public ArithmeticError + { + public: + FloatingPointError (const std::string& reason) + : ArithmeticError() + { + PyErr_SetString( Py::_Exc_FloatingPointError(), reason.c_str() ); + } + }; + + class MemoryError: public StandardError + { + public: + MemoryError (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_MemoryError(), reason.c_str() ); + } + }; + + class SystemExit: public StandardError + { + public: + SystemExit (const std::string& reason) + : StandardError() + { + PyErr_SetString( Py::_Exc_SystemExit(),reason.c_str() ); + } + }; + +}// Py + +#endif diff --git a/src/CXX/Python3/ExtensionModule.hxx b/src/CXX/Python3/ExtensionModule.hxx new file mode 100644 index 000000000..75eb77568 --- /dev/null +++ b/src/CXX/Python3/ExtensionModule.hxx @@ -0,0 +1,204 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_ExtensionModule__h +#define __CXX_ExtensionModule__h + +namespace Py +{ + class ExtensionModuleBase + { + public: + ExtensionModuleBase( const char *name ); + virtual ~ExtensionModuleBase(); + + Module module( void ) const; // only valid after initialize() has been called + Dict moduleDictionary( void ) const; // only valid after initialize() has been called + + virtual Object invoke_method_noargs( void *method_def ) = 0; + virtual Object invoke_method_keyword( void *method_def, const Tuple &_args, const Dict &_keywords ) = 0; + virtual Object invoke_method_varargs( void *method_def, const Tuple &_args ) = 0; + + const std::string &name() const; + const std::string &fullName() const; + + // what is returned from PyInit_ function + Object moduleObject( void ) const; + + protected: + // Initialize the module + void initialize( const char *module_doc ); + + const std::string m_module_name; + const std::string m_full_module_name; + MethodTable m_method_table; + PyModuleDef m_module_def; + PyObject *m_module; + + private: + // + // prevent the compiler generating these unwanted functions + // + ExtensionModuleBase( const ExtensionModuleBase & ); //unimplemented + void operator=( const ExtensionModuleBase & ); //unimplemented + }; + + // Note: Python calls noargs as varargs buts args==NULL + extern "C" PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ); + extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ); + extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ); + + template + class ExtensionModule : public ExtensionModuleBase + { + public: + ExtensionModule( const char *name ) + : ExtensionModuleBase( name ) + {} + virtual ~ExtensionModule() + {} + + protected: + typedef Object (T::*method_noargs_function_t)(); + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + typedef std::map *> method_map_t; + + static void add_noargs_method( const char *name, method_noargs_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_noargs_call_handler, doc ); + } + + static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_varargs_call_handler, doc ); + } + + static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" ) + { + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_keyword_call_handler, doc ); + } + + void initialize( const char *module_doc="" ) + { + ExtensionModuleBase::initialize( module_doc ); + Dict dict( moduleDictionary() ); + + // + // put each of the methods into the modules dictionary + // so that we get called back at the function in T. + // + method_map_t &mm = methods(); + EXPLICIT_TYPENAME method_map_t::const_iterator i = mm.begin(); + EXPLICIT_TYPENAME method_map_t::const_iterator i_end = mm.end(); + for ( ; i != i_end; ++i ) + { + MethodDefExt *method_def = (*i).second; + + static PyObject *self = PyCapsule_New( this, NULL, NULL ); + + Tuple args( 2 ); + args[0] = Object( self, true ); + args[1] = Object( PyCapsule_New( method_def, NULL, NULL ), true ); + + PyObject *func = PyCFunction_New + ( + &method_def->ext_meth_def, + new_reference_to( args ) + ); + + method_def->py_method = Object( func, true ); + + dict[ (*i).first ] = method_def->py_method; + } + } + + protected: // Tom Malcolmson reports that derived classes need access to these + static method_map_t &methods( void ) + { + static method_map_t *map_of_methods = NULL; + if( map_of_methods == NULL ) + map_of_methods = new method_map_t; + + return *map_of_methods; + } + + // this invoke function must be called from within a try catch block + virtual Object invoke_method_noargs( void *method_def ) + { + // cast up to the derived class, method_def and call + T *self = static_cast( this ); + MethodDefExt *meth_def = reinterpret_cast *>( method_def ); + + return (self->*meth_def->ext_noargs_function)(); + } + + // this invoke function must be called from within a try catch block + virtual Object invoke_method_varargs( void *method_def, const Tuple &args ) + { + // cast up to the derived class, method_def and call + T *self = static_cast( this ); + MethodDefExt *meth_def = reinterpret_cast *>( method_def ); + + return (self->*meth_def->ext_varargs_function)( args ); + } + + // this invoke function must be called from within a try catch block + virtual Object invoke_method_keyword( void *method_def, const Tuple &args, const Dict &keywords ) + { + // cast up to the derived class, method_def and call + T *self = static_cast( this ); + MethodDefExt *meth_def = reinterpret_cast *>( method_def ); + + return (self->*meth_def->ext_keyword_function)( args, keywords ); + } + + private: + // + // prevent the compiler generating these unwanted functions + // + ExtensionModule( const ExtensionModule & ); //unimplemented + void operator=( const ExtensionModule & ); //unimplemented + }; +} // Namespace Py + + +// End of __CXX_ExtensionModule__h +#endif diff --git a/src/CXX/Python3/ExtensionOldType.hxx b/src/CXX/Python3/ExtensionOldType.hxx new file mode 100644 index 000000000..355dcfb22 --- /dev/null +++ b/src/CXX/Python3/ExtensionOldType.hxx @@ -0,0 +1,398 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_ExtensionOldType__h +#define __CXX_ExtensionOldType__h + +namespace Py +{ + template class PythonExtension + : public PythonExtensionBase + { + public: + static PyTypeObject *type_object() + { + return behaviors().type_object(); + } + + static bool check( PyObject *p ) + { + // is p like me? + return p->ob_type == type_object(); + } + + static bool check( const Object &ob ) + { + return check( ob.ptr() ); + } + + // + // every object needs getattr implemented + // to support methods + // + virtual Object getattr( const char *name ) + { + return getattr_methods( name ); + } + + PyObject *selfPtr() + { + return this; + } + + Object self() + { + return asObject( this ); + } + + protected: + explicit PythonExtension() + : PythonExtensionBase() + { + PyObject_Init( this, type_object() ); + + // every object must support getattr + behaviors().supportGetattr(); + } + + virtual ~PythonExtension() + {} + + static PythonType &behaviors() + { + static PythonType* p; + if( p == NULL ) + { +#if defined( _CPPRTTI ) || defined( __GNUG__ ) + const char *default_name =( typeid( T ) ).name(); +#else + const char *default_name = "unknown"; +#endif + p = new PythonType( sizeof( T ), 0, default_name ); + p->set_tp_dealloc( extension_object_deallocator ); + } + + return *p; + } + + typedef Object (T::*method_noargs_function_t)(); + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + typedef std::map *> method_map_t; + + // support the default attributes, __name__, __doc__ and methods + virtual Object getattr_default( const char *_name ) + { + std::string name( _name ); + + if( name == "__name__" && type_object()->tp_name != NULL ) + { + return Py::String( type_object()->tp_name ); + } + + if( name == "__doc__" && type_object()->tp_doc != NULL ) + { + return Py::String( type_object()->tp_doc ); + } + +// trying to fake out being a class for help() +// else if( name == "__bases__" ) +// { +// return Py::Tuple( 0 ); +// } +// else if( name == "__module__" ) +// { +// return Py::Nothing(); +// } +// else if( name == "__dict__" ) +// { +// return Py::Dict(); +// } + + return getattr_methods( _name ); + } + + // turn a name into function object + virtual Object getattr_methods( const char *_name ) + { + std::string name( _name ); + + method_map_t &mm = methods(); + + // see if name exists and get entry with method + EXPLICIT_TYPENAME method_map_t::const_iterator i = mm.find( name ); + if( i == mm.end() ) + { + if( name == "__methods__" ) + { + List methods; + + i = mm.begin(); + EXPLICIT_TYPENAME method_map_t::const_iterator i_end = mm.end(); + + for( ; i != i_end; ++i ) + methods.append( String( (*i).first ) ); + + return methods; + } + + throw AttributeError( name ); + } + + MethodDefExt *method_def = i->second; + + Tuple self( 2 ); + + self[0] = Object( this ); + self[1] = Object( PyCapsule_New( method_def, NULL, NULL ), true ); + + PyObject *func = PyCFunction_New( &method_def->ext_meth_def, self.ptr() ); + + return Object(func, true); + } + + // check that all methods added are unique + static void check_unique_method_name( const char *name ) + { + method_map_t &mm = methods(); + EXPLICIT_TYPENAME method_map_t::const_iterator i; + i = mm.find( name ); + if( i != mm.end() ) + throw AttributeError( name ); + } + + static void add_noargs_method( const char *name, method_noargs_function_t function, const char *doc="" ) + { + check_unique_method_name( name ); + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_noargs_call_handler, doc ); + } + + static void add_varargs_method( const char *name, method_varargs_function_t function, const char *doc="" ) + { + check_unique_method_name( name ); + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_varargs_call_handler, doc ); + } + + static void add_keyword_method( const char *name, method_keyword_function_t function, const char *doc="" ) + { + check_unique_method_name( name ); + method_map_t &mm = methods(); + mm[ std::string( name ) ] = new MethodDefExt( name, function, method_keyword_call_handler, doc ); + } + + private: + static method_map_t &methods( void ) + { + static method_map_t *map_of_methods = NULL; + if( map_of_methods == NULL ) + map_of_methods = new method_map_t; + + return *map_of_methods; + } + + // Note: Python calls noargs as varargs buts args==NULL + static PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ) + { + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + T *self = static_cast( self_in_cobject ); + + MethodDefExt *meth_def = reinterpret_cast *>( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ) ); + + Object result; + + // Adding try & catch in case of STL debug-mode exceptions. + #ifdef _STLP_DEBUG + try + { + result = (self->*meth_def->ext_noargs_function)(); + } + catch( std::__stl_debug_exception ) + { + // throw cxx::RuntimeError( sErrMsg ); + throw RuntimeError( "Error message not set yet." ); + } + #else + result = (self->*meth_def->ext_noargs_function)(); + #endif // _STLP_DEBUG + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } + } + + static PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ) + { + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + T *self = static_cast( self_in_cobject ); + MethodDefExt *meth_def = reinterpret_cast *>( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ) ); + + Tuple args( _args ); + + Object result; + + // Adding try & catch in case of STL debug-mode exceptions. + #ifdef _STLP_DEBUG + try + { + result = (self->*meth_def->ext_varargs_function)( args ); + } + catch( std::__stl_debug_exception ) + { + throw RuntimeError( "Error message not set yet." ); + } + #else + result = (self->*meth_def->ext_varargs_function)( args ); + #endif // _STLP_DEBUG + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } + } + + static PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ) + { + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + T *self = static_cast( self_in_cobject ); + MethodDefExt *meth_def = reinterpret_cast *>( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ) ); + + Tuple args( _args ); + + // _keywords may be NULL so be careful about the way the dict is created + Dict keywords; + if( _keywords != NULL ) + keywords = Dict( _keywords ); + + Object result( ( self->*meth_def->ext_keyword_function )( args, keywords ) ); + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } + } + + static void extension_object_deallocator( PyObject* t ) + { + delete (T *)( t ); + } + + // + // prevent the compiler generating these unwanted functions + // + explicit PythonExtension( const PythonExtension &other ); + void operator=( const PythonExtension &rhs ); + }; + + // + // ExtensionObject is an Object that will accept only T's. + // + template + class ExtensionObject: public Object + { + public: + + explicit ExtensionObject( PyObject *pyob ) + : Object( pyob ) + { + validate(); + } + + ExtensionObject( const ExtensionObject &other ) + : Object( *other ) + { + validate(); + } + + ExtensionObject( const Object &other ) + : Object( *other ) + { + validate(); + } + + ExtensionObject &operator=( const Object &rhs ) + { + return( *this = *rhs ); + } + + ExtensionObject &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + virtual bool accepts( PyObject *pyob ) const + { + return( pyob && T::check( pyob ) ); + } + + // + // Obtain a pointer to the PythonExtension object + // + T *extensionObject( void ) + { + return static_cast( ptr() ); + } + }; +} // Namespace Py + +// End of __CXX_ExtensionOldType__h +#endif diff --git a/src/CXX/Python3/ExtensionType.hxx b/src/CXX/Python3/ExtensionType.hxx new file mode 100644 index 000000000..df680dbdf --- /dev/null +++ b/src/CXX/Python3/ExtensionType.hxx @@ -0,0 +1,403 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_ExtensionClass__h +#define __CXX_ExtensionClass__h + +#define PYCXX_NOARGS_METHOD_NAME( NAME ) _callNoArgsMethod__##NAME +#define PYCXX_VARARGS_METHOD_NAME( NAME ) _callVarArgsMethod__##NAME +#define PYCXX_KEYWORDS_METHOD_NAME( NAME ) _callKeywordsMethod__##NAME + +#define PYCXX_NOARGS_METHOD_DECL( CLS, NAME ) \ + static PyObject *PYCXX_NOARGS_METHOD_NAME( NAME )( PyObject *_self, PyObject *, PyObject * ) \ + { \ + try \ + { \ + Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \ + CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \ + Py::Object r( (self->NAME)() ); \ + return Py::new_reference_to( r.ptr() ); \ + } \ + catch( Py::Exception & ) \ + { \ + return 0; \ + } \ + } +#define PYCXX_VARARGS_METHOD_DECL( CLS, NAME ) \ + static PyObject *PYCXX_VARARGS_METHOD_NAME( NAME )( PyObject *_self, PyObject *_a, PyObject * ) \ + { \ + try \ + { \ + Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \ + CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \ + Py::Tuple a( _a ); \ + Py::Object r( (self->NAME)( a ) ); \ + return Py::new_reference_to( r.ptr() ); \ + } \ + catch( Py::Exception & ) \ + { \ + return 0; \ + } \ + } +#define PYCXX_KEYWORDS_METHOD_DECL( CLS, NAME ) \ + static PyObject *PYCXX_KEYWORDS_METHOD_NAME( NAME )( PyObject *_self, PyObject *_a, PyObject *_k ) \ + { \ + try \ + { \ + Py::PythonClassInstance *self_python = reinterpret_cast< Py::PythonClassInstance * >( _self ); \ + CLS *self = reinterpret_cast< CLS * >( self_python->m_pycxx_object ); \ + Py::Tuple a( _a ); \ + Py::Dict k; \ + if( _k != NULL ) \ + k = _k; \ + Py::Object r( (self->NAME)( a, k ) ); \ + return Py::new_reference_to( r.ptr() ); \ + } \ + catch( Py::Exception & ) \ + { \ + return 0; \ + } \ + } + +// need to support METH_STATIC and METH_CLASS + +#define PYCXX_ADD_NOARGS_METHOD( PYNAME, NAME, docs ) \ + add_method( #PYNAME, (PyCFunction)PYCXX_NOARGS_METHOD_NAME( NAME ), METH_NOARGS, docs ) +#define PYCXX_ADD_VARARGS_METHOD( PYNAME, NAME, docs ) \ + add_method( #PYNAME, (PyCFunction)PYCXX_VARARGS_METHOD_NAME( NAME ), METH_VARARGS, docs ) +#define PYCXX_ADD_KEYWORDS_METHOD( PYNAME, NAME, docs ) \ + add_method( #PYNAME, (PyCFunction)PYCXX_KEYWORDS_METHOD_NAME( NAME ), METH_VARARGS | METH_KEYWORDS, docs ) + +namespace Py +{ + extern PythonExtensionBase *getPythonExtensionBase( PyObject *self ); + struct PythonClassInstance + { + PyObject_HEAD + PythonExtensionBase *m_pycxx_object; + }; + + + class ExtensionClassMethodsTable + { + public: + ExtensionClassMethodsTable() + : m_methods_table( new PyMethodDef[ METHOD_TABLE_SIZE_INCREMENT ] ) + , m_methods_used( 0 ) + , m_methods_size( METHOD_TABLE_SIZE_INCREMENT ) + { + } + + ~ExtensionClassMethodsTable() + { + delete m_methods_table; + } + + // check that all methods added are unique + void check_unique_method_name( const char *_name ) + { + std::string name( _name ); + for( int i=0; iml_name = name; + p->ml_meth = function; + p->ml_flags = flags; + p->ml_doc = doc; + + m_methods_used++; + p++; + + // add the sentinel marking the table end + p->ml_name = NULL; + p->ml_meth = NULL; + p->ml_flags = 0; + p->ml_doc = NULL; + + return m_methods_table; + } + + private: + enum {METHOD_TABLE_SIZE_INCREMENT = 1}; + PyMethodDef *m_methods_table; + int m_methods_used; + int m_methods_size; + }; + + template class PythonClass + : public PythonExtensionBase + { + protected: + explicit PythonClass( PythonClassInstance *self, Tuple &args, Dict &kwds ) + : PythonExtensionBase() + , m_class_instance( self ) + { + } + + virtual ~PythonClass() + {} + + static ExtensionClassMethodsTable &methodTable() + { + static ExtensionClassMethodsTable *method_table; + if( method_table == NULL ) + method_table = new ExtensionClassMethodsTable; + return *method_table; + } + + static void add_method( const char *name, PyCFunction function, int flags, const char *doc=NULL ) + { + behaviors().set_methods( methodTable().add_method( name, function, flags, doc ) ); + } + + static PythonType &behaviors() + { + static PythonType *p; + if( p == NULL ) + { +#if defined( _CPPRTTI ) || defined( __GNUG__ ) + const char *default_name = (typeid( T )).name(); +#else + const char *default_name = "unknown"; +#endif + p = new PythonType( sizeof( T ), 0, default_name ); + p->set_tp_new( extension_object_new ); + p->set_tp_init( extension_object_init ); + p->set_tp_dealloc( extension_object_deallocator ); + + // we are a class + p->supportClass(); + + // always support get and set attr + p->supportGetattro(); + p->supportSetattro(); + } + + return *p; + } + + static PyObject *extension_object_new( PyTypeObject *subtype, PyObject *args, PyObject *kwds ) + { +#ifdef PYCXX_DEBUG + std::cout << "extension_object_new()" << std::endl; +#endif + PythonClassInstance *o = reinterpret_cast( subtype->tp_alloc( subtype, 0 ) ); + if( o == NULL ) + return NULL; + + o->m_pycxx_object = NULL; + + PyObject *self = reinterpret_cast( o ); +#ifdef PYCXX_DEBUG + std::cout << "extension_object_new() => self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << std::endl; +#endif + return self; + } + + static int extension_object_init( PyObject *_self, PyObject *args_, PyObject *kwds_ ) + { + try + { + Py::Tuple args( args_ ); + Py::Dict kwds; + if( kwds_ != NULL ) + kwds = kwds_; + + PythonClassInstance *self = reinterpret_cast( _self ); +#ifdef PYCXX_DEBUG + std::cout << "extension_object_init( self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << " )" << std::endl; + std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl; +#endif + + if( self->m_pycxx_object == NULL ) + { + self->m_pycxx_object = new T( self, args, kwds ); +#ifdef PYCXX_DEBUG + std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl; +#endif + } + else + { +#ifdef PYCXX_DEBUG + std::cout << " reinit - self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl; +#endif + self->m_pycxx_object->reinit( args, kwds ); + } + } + catch( Exception & ) + { + return -1; + } + return 0; + } + + static void extension_object_deallocator( PyObject *_self ) + { + PythonClassInstance *self = reinterpret_cast< PythonClassInstance * >( _self ); +#ifdef PYCXX_DEBUG + std::cout << "extension_object_deallocator( self=0x" << std::hex << reinterpret_cast< unsigned int >( self ) << std::dec << " )" << std::endl; + std::cout << " self->m_pycxx_object=0x" << std::hex << reinterpret_cast< unsigned int >( self->m_pycxx_object ) << std::dec << std::endl; +#endif + delete self->m_pycxx_object; + _self->ob_type->tp_free( _self ); + } + + public: + static PyTypeObject *type_object() + { + return behaviors().type_object(); + } + + static Object type() + { + return Object( reinterpret_cast( behaviors().type_object() ) ); + } + + static bool check( PyObject *p ) + { + // is p like me? + return p->ob_type == type_object(); + } + + static bool check( const Object &ob ) + { + return check( ob.ptr() ); + } + + virtual PyObject *selfPtr() + { + return reinterpret_cast( m_class_instance ); + } + + virtual Object self() + { + return Object( reinterpret_cast( m_class_instance ) ); + } + + protected: + private: + PythonClassInstance *m_class_instance; + + private: + // + // prevent the compiler generating these unwanted functions + // + explicit PythonClass( const PythonClass &other ); + void operator=( const PythonClass &rhs ); + }; + + // + // ExtensionObject is an Object that will accept only T's. + // + template + class PythonClassObject: public Object + { + public: + + explicit PythonClassObject( PyObject *pyob ) + : Object( pyob ) + { + validate(); + } + + PythonClassObject( const PythonClassObject &other ) + : Object( *other ) + { + validate(); + } + + PythonClassObject( const Object &other ) + : Object( *other ) + { + validate(); + } + + PythonClassObject &operator=( const Object &rhs ) + { + *this = *rhs; + return *this; + } + + PythonClassObject &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + virtual bool accepts( PyObject *pyob ) const + { + return( pyob && T::check( pyob ) ); + } + + // + // Obtain a pointer to the PythonExtension object + // + T *getCxxObject( void ) + { + return dynamic_cast< T * >( getPythonExtensionBase( ptr() ) ); + } + }; +} // Namespace Py + +// End of __CXX_ExtensionClass__h +#endif diff --git a/src/CXX/Python3/ExtensionTypeBase.hxx b/src/CXX/Python3/ExtensionTypeBase.hxx new file mode 100644 index 000000000..09c74c20c --- /dev/null +++ b/src/CXX/Python3/ExtensionTypeBase.hxx @@ -0,0 +1,170 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_ExtensionTypeBase__h +#define __CXX_ExtensionTypeBase__h + +namespace Py +{ + // Class PythonExtension is what you inherit from to create + // a new Python extension type. You give your class itself + // as the template paramter. + + // There are two ways that extension objects can get destroyed. + // 1. Their reference count goes to zero + // 2. Someone does an explicit delete on a pointer. + // In(1) the problem is to get the destructor called + // We register a special deallocator in the Python type object + // (see behaviors()) to do this. + // In(2) there is no problem, the dtor gets called. + + // PythonExtension does not use the usual Python heap allocator, + // instead using new/delete. We do the setting of the type object + // and reference count, usually done by PyObject_New, in the + // base class ctor. + + // This special deallocator does a delete on the pointer. + + class PythonExtensionBase : public PyObject + { + public: + PythonExtensionBase(); + virtual ~PythonExtensionBase(); + + public: + // object + virtual void reinit( Tuple &args, Dict &kwds ); + + // object basics +#ifdef PYCXX_PYTHON_2TO3 + virtual int print( FILE *, int ); +#endif + virtual Object getattr( const char * ); + virtual int setattr( const char *, const Object & ); + virtual Object getattro( const String & ); + Object genericGetAttro( const String & ); + virtual int setattro( const String &, const Object & ); + int genericSetAttro( const String &, const Object & ); + virtual int compare( const Object & ); + virtual Object rich_compare( const Object &, int ); + virtual Object repr(); + virtual Object str(); + virtual long hash(); + virtual Object call( const Object &, const Object & ); + virtual Object iter(); + virtual PyObject *iternext(); + + // Sequence methods + virtual int sequence_length(); + virtual Object sequence_concat( const Object & ); + virtual Object sequence_repeat( Py_ssize_t ); + virtual Object sequence_item( Py_ssize_t ); + virtual int sequence_ass_item( Py_ssize_t, const Object & ); + + // Mapping + virtual int mapping_length(); + virtual Object mapping_subscript( const Object & ); + virtual int mapping_ass_subscript( const Object &, const Object & ); + + // Number + virtual Object number_negative(); + virtual Object number_positive(); + virtual Object number_absolute(); + virtual Object number_invert(); + virtual Object number_int(); + virtual Object number_float(); + virtual Object number_long(); + virtual Object number_add( const Object & ); + virtual Object number_subtract( const Object & ); + virtual Object number_multiply( const Object & ); + virtual Object number_remainder( const Object & ); + virtual Object number_divmod( const Object & ); + virtual Object number_lshift( const Object & ); + virtual Object number_rshift( const Object & ); + virtual Object number_and( const Object & ); + virtual Object number_xor( const Object & ); + virtual Object number_or( const Object & ); + virtual Object number_power( const Object &, const Object & ); + + // Buffer + virtual int buffer_get( Py_buffer *, int flags ); + virtual int buffer_release( Py_buffer *buf ); + + public: + // helper functions to call function fn_name with 0 to 9 args + Object callOnSelf( const std::string &fn_name ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4, const Object &arg5 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4, const Object &arg5, const Object &arg6 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4, const Object &arg5, const Object &arg6, + const Object &arg7 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4, const Object &arg5, const Object &arg6, + const Object &arg7, const Object &arg8 ); + Object callOnSelf( const std::string &fn_name, + const Object &arg1, const Object &arg2, const Object &arg3, + const Object &arg4, const Object &arg5, const Object &arg6, + const Object &arg7, const Object &arg8, const Object &arg9 ); + + public: + virtual PyObject *selfPtr() = 0; + virtual Object self() = 0; + + private: + void missing_method( void ); + static PyObject *method_call_handler( PyObject *self, PyObject *args ); + }; + +} // Namespace Py + +// End of __CXX_ExtensionTypeBase__h +#endif diff --git a/src/CXX/Python3/Extensions.hxx b/src/CXX/Python3/Extensions.hxx new file mode 100644 index 000000000..7533d97c7 --- /dev/null +++ b/src/CXX/Python3/Extensions.hxx @@ -0,0 +1,189 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Extensions__h +#define __CXX_Extensions__h + + +#ifdef _MSC_VER +// disable warning C4786: symbol greater than 255 character, +// okay to ignore +#pragma warning( disable: 4786 ) +#endif + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Python3/Config.hxx" +#include "CXX/Python3/CxxDebug.hxx" +#include "CXX/Python3/Objects.hxx" + +extern "C" { extern PyObject py_object_initializer; } + +#include +#include + +// ---------------------------------------------------------------------- + +namespace Py +{ + class ExtensionModuleBase; + + // Make an Exception Type for use in raising custom exceptions + class ExtensionExceptionType : public Object + { + public: + ExtensionExceptionType(); + virtual ~ExtensionExceptionType(); + + // call init to create the type + void init( ExtensionModuleBase &module, const std::string &name, ExtensionExceptionType &parent ); + void init( ExtensionModuleBase &module, const std::string &name ); + }; + + class MethodTable + { + public: + MethodTable(); + virtual ~MethodTable(); + + void add( const char *method_name, PyCFunction f, const char *doc="", int flag=1 ); + PyMethodDef *table(); + + protected: + std::vector t; // accumulator of PyMethodDef's + PyMethodDef *mt; // Actual method table produced when full + + static PyMethodDef method( const char* method_name, PyCFunction f, int flags=1, const char* doc="" ); + + private: + // + // prevent the compiler generating these unwanted functions + // + MethodTable( const MethodTable &m ); //unimplemented + void operator=( const MethodTable &m ); //unimplemented + + }; // end class MethodTable + + // Note: Python calls noargs as varargs buts args==NULL + extern "C" typedef PyObject *(*method_noargs_call_handler_t)( PyObject *_self, PyObject * ); + extern "C" typedef PyObject *(*method_varargs_call_handler_t)( PyObject *_self, PyObject *_args ); + extern "C" typedef PyObject *(*method_keyword_call_handler_t)( PyObject *_self, PyObject *_args, PyObject *_dict ); + + template + class MethodDefExt : public PyMethodDef + { + public: + typedef Object (T::*method_noargs_function_t)(); + typedef Object (T::*method_varargs_function_t)( const Tuple &args ); + typedef Object (T::*method_keyword_function_t)( const Tuple &args, const Dict &kws ); + + // NOARGS + MethodDefExt + ( + const char *_name, + method_noargs_function_t _function, + method_noargs_call_handler_t _handler, + const char *_doc + ) + { + ext_meth_def.ml_name = const_cast( _name ); + ext_meth_def.ml_meth = reinterpret_cast( _handler ); + ext_meth_def.ml_flags = METH_NOARGS; + ext_meth_def.ml_doc = const_cast( _doc ); + + ext_noargs_function = _function; + ext_varargs_function = NULL; + ext_keyword_function = NULL; + } + + // VARARGS + MethodDefExt + ( + const char *_name, + method_varargs_function_t _function, + method_varargs_call_handler_t _handler, + const char *_doc + ) + { + ext_meth_def.ml_name = const_cast( _name ); + ext_meth_def.ml_meth = reinterpret_cast( _handler ); + ext_meth_def.ml_flags = METH_VARARGS; + ext_meth_def.ml_doc = const_cast( _doc ); + + ext_noargs_function = NULL; + ext_varargs_function = _function; + ext_keyword_function = NULL; + } + + // VARARGS + KEYWORD + MethodDefExt + ( + const char *_name, + method_keyword_function_t _function, + method_keyword_call_handler_t _handler, + const char *_doc + ) + { + ext_meth_def.ml_name = const_cast( _name ); + ext_meth_def.ml_meth = reinterpret_cast( _handler ); + ext_meth_def.ml_flags = METH_VARARGS|METH_KEYWORDS; + ext_meth_def.ml_doc = const_cast( _doc ); + + ext_noargs_function = NULL; + ext_varargs_function = NULL; + ext_keyword_function = _function; + } + + ~MethodDefExt() + {} + + PyMethodDef ext_meth_def; + method_noargs_function_t ext_noargs_function; + method_varargs_function_t ext_varargs_function; + method_keyword_function_t ext_keyword_function; + Object py_method; + }; +} // Namespace Py + +#include "CXX/Python3/ExtensionModule.hxx" +#include "CXX/Python3/PythonType.hxx" +#include "CXX/Python3/ExtensionTypeBase.hxx" +#include "CXX/Python3/ExtensionOldType.hxx" +#include "CXX/Python3/ExtensionType.hxx" + +// End of CXX_Extensions.h +#endif diff --git a/src/CXX/Python3/IndirectPythonInterface.hxx b/src/CXX/Python3/IndirectPythonInterface.hxx new file mode 100644 index 000000000..cdae3ad35 --- /dev/null +++ b/src/CXX/Python3/IndirectPythonInterface.hxx @@ -0,0 +1,183 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ +#define __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ + +#include "CXX/WrapPython.h" + +namespace Py +{ +bool InitialisePythonIndirectInterface(); + +// +// Wrap Exception variables as function calls +// +PyObject * _Exc_Exception(); +PyObject * _Exc_StandardError(); +PyObject * _Exc_ArithmeticError(); +PyObject * _Exc_LookupError(); + +PyObject * _Exc_AssertionError(); +PyObject * _Exc_AttributeError(); +PyObject * _Exc_EOFError(); +PyObject * _Exc_FloatingPointError(); +PyObject * _Exc_EnvironmentError(); +PyObject * _Exc_IOError(); +PyObject * _Exc_OSError(); +PyObject * _Exc_ImportError(); +PyObject * _Exc_IndexError(); +PyObject * _Exc_KeyError(); +PyObject * _Exc_KeyboardInterrupt(); +PyObject * _Exc_MemoryError(); +PyObject * _Exc_NameError(); +PyObject * _Exc_OverflowError(); +PyObject * _Exc_RuntimeError(); +PyObject * _Exc_NotImplementedError(); +PyObject * _Exc_SyntaxError(); +PyObject * _Exc_SystemError(); +PyObject * _Exc_SystemExit(); +PyObject * _Exc_TypeError(); +PyObject * _Exc_ValueError(); +PyObject * _Exc_ZeroDivisionError(); +#ifdef MS_WINDOWS +PyObject * _Exc_WindowsError(); +#endif + +PyObject * _Exc_IndentationError(); +PyObject * _Exc_TabError(); +PyObject * _Exc_UnboundLocalError(); +PyObject * _Exc_UnicodeError(); + +// +// Wrap Object variables as function calls +// +PyObject * _None(); + +PyObject * _False(); +PyObject * _True(); + +// +// Wrap Type variables as function calls +// +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *o ); + +PyTypeObject * _Buffer_Type(); +bool _Buffer_Check( PyObject *op ); + +PyTypeObject * _Class_Type(); +bool _Class_Check( PyObject *op ); + +PyTypeObject * _Instance_Type(); +bool _Instance_Check( PyObject *op ); + +PyTypeObject * _Method_Type(); +bool _Method_Check( PyObject *op ); + +PyTypeObject * _Complex_Type(); +bool _Complex_Check( PyObject *op ); + +PyTypeObject * _Dict_Type(); +bool _Dict_Check( PyObject *op ); + +PyTypeObject * _File_Type(); +bool _File_Check( PyObject *op ); + +PyTypeObject * _Float_Type(); +bool _Float_Check( PyObject *op ); + +PyTypeObject * _Frame_Type(); +bool _Frame_Check( PyObject *op ); + +PyTypeObject * _Function_Type(); +bool _Function_Check( PyObject *op ); + +PyTypeObject * _Bool_Type(); +bool _Boolean_Check( PyObject *op ); + +PyTypeObject * _Int_Type(); +bool _Int_Check( PyObject *op ); + +PyTypeObject * _List_Type(); +bool _List_Check( PyObject *op ); + +PyTypeObject * _Long_Type(); +bool _Long_Check( PyObject *op ); + +PyTypeObject * _CFunction_Type(); +bool _CFunction_Check( PyObject *op ); + +PyTypeObject * _Module_Type(); +bool _Module_Check( PyObject *op ); + +PyTypeObject * _Type_Type(); +bool _Type_Check( PyObject *op ); + +PyTypeObject * _Range_Type(); +bool _Range_Check( PyObject *op ); + +PyTypeObject * _Slice_Type(); +bool _Slice_Check( PyObject *op ); + +PyTypeObject * _Unicode_Type(); +bool _Unicode_Check( PyObject *op ); + +PyTypeObject * _Bytes_Type(); +bool _Bytes_Check( PyObject *op ); + +PyTypeObject * _TraceBack_Type(); +bool _TraceBack_Check( PyObject *v ); + +PyTypeObject * _Tuple_Type(); +bool _Tuple_Check( PyObject *op ); + +int &_Py_DebugFlag(); +int &_Py_InteractiveFlag(); +int &_Py_OptimizeFlag(); +int &_Py_NoSiteFlag(); +int &_Py_TabcheckFlag(); +int &_Py_VerboseFlag(); +int &_Py_UnicodeFlag(); + +void _XINCREF( PyObject *op ); +void _XDECREF( PyObject *op ); + +char *__Py_PackageContext(); +}; + +#endif // __CXX_INDIRECT_PYTHON_INTERFACE__HXX__ diff --git a/src/CXX/Python3/Objects.hxx b/src/CXX/Python3/Objects.hxx new file mode 100644 index 000000000..36f84c2b8 --- /dev/null +++ b/src/CXX/Python3/Objects.hxx @@ -0,0 +1,3426 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_Objects__h +#define __CXX_Objects__h + +#include "CXX/WrapPython.h" +#include "CXX/Version.hxx" +#include "CXX/Python3/Config.hxx" +#include "CXX/Python3/CxxDebug.hxx" +#include "CXX/Python3/Exception.hxx" + +#include +#include STR_STREAM +#include +#include +#include +#include + +namespace Py +{ + typedef int sequence_index_type; // type of an index into a sequence + + // Forward declarations + class Object; + class Type; + template class SeqBase; + class Bytes; + class String; + class List; + template class MapBase; + class Tuple; + class Dict; + + //===========================================================================// + // class Object + // The purpose of this class is to serve as the most general kind of + // Python object, for the purpose of writing C++ extensions in Python + // Objects hold a PyObject* which they own. This pointer is always a + // valid pointer to a Python object. In children we must maintain this behavior. + // + // Instructions on how to make your own class MyType descended from Object: + // (0) Pick a base class, either Object or perhaps SeqBase or MapBase. + // This example assumes Object. + + // (1) Write a routine int MyType_Check( PyObject * ) modeled after PyInt_Check, + // PyFloat_Check, etc. + + // (2) Add method accepts: + // virtual bool accepts( PyObject *pyob ) const { + // return pyob && MyType_Check( pyob ); + // } + + // (3) Include the following constructor and copy constructor + // + /* + explicit MyType( PyObject *pyob ): Object( pyob ) + { + validate(); + } + + MyType( const Object &other ): Object( other.ptr() ) + { + validate(); + } + */ + + // Alernate version for the constructor to allow for construction from owned pointers: + /* + explicit MyType( PyObject *pyob ): Object( pyob ) + { + validate(); + } + */ + + // You may wish to add other constructors; see the classes below for examples. + // Each constructor must use "set" to set the pointer + // and end by validating the pointer you have created. + + //( 4 ) Each class needs at least these two assignment operators: + /* + MyType &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Mytype &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + */ + // Note on accepts: constructors call the base class + // version of a virtual when calling the base class constructor, + // so the test has to be done explicitly in a descendent. + + // If you are inheriting from PythonExtension to define an object + // note that it contains PythonExtension::check + // which you can use in accepts when writing a wrapper class. + // See Demo/range.h and Demo/range.cxx for an example. + + class Object + { + private: + // the pointer to the Python object + // Only Object sets this directly. + // The default constructor for Object sets it to Py_None and + // child classes must use "set" to set it + // + PyObject *p; + + protected: + void set( PyObject *pyob, bool owned = false ) + { + release(); + p = pyob; + if( !owned ) + { + Py::_XINCREF( p ); + } + validate(); + } + + void release() + { + Py::_XDECREF( p ); + p = NULL; + } + + void validate(); + + public: + // Constructor acquires new ownership of pointer unless explicitly told not to. + explicit Object( PyObject *pyob=Py::_None(), bool owned = false ) + : p( pyob ) + { + if( !owned ) + { + Py::_XINCREF( p ); + } + validate(); + } + + // Copy constructor acquires new ownership of pointer + Object( const Object &ob ) + : p( ob.p ) + { + Py::_XINCREF( p ); + validate(); + } + + // Assignment acquires new ownership of pointer + Object &operator=( const Object &rhs ) + { + set( rhs.p ); + return *this; + } + + Object &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + + return *this; + } + + // Destructor + virtual ~Object() + { + release(); + } + + // Loaning the pointer to others, retain ownership + PyObject *operator*() const + { + return p; + } + + // Explicit reference_counting changes + void increment_reference_count() + { + Py::_XINCREF( p ); + } + + void decrement_reference_count() + { + // not allowed to commit suicide, however + if( reference_count() == 1 ) + throw RuntimeError( "Object::decrement_reference_count error." ); + Py::_XDECREF( p ); + } + + // Would like to call this pointer() but messes up STL in SeqBase + PyObject *ptr() const + { + return p; + } + + // + // Queries + // + + // Can pyob be used in this object's constructor? + virtual bool accepts( PyObject *pyob ) const + { + // allow any object or NULL + return true; + } + + Py_ssize_t reference_count() const + { // the reference count + return p ? p->ob_refcnt : 0; + } + + Type type() const; // the type object associated with this one + + String str() const; // the str() representation + + std::string as_string() const; + + String repr() const; // the repr() representation + + List dir() const; // the dir() list + + bool hasAttr( const std::string &s ) const + { + return PyObject_HasAttrString( p, const_cast( s.c_str() ) ) ? true: false; + } + + Object getAttr( const std::string &s ) const + { + return Object( PyObject_GetAttrString( p, const_cast( s.c_str() ) ), true ); + } + + Object callMemberFunction( const std::string &function_name ) const; + Object callMemberFunction( const std::string &function_name, const Tuple &args ) const; + Object callMemberFunction( const std::string &function_name, const Tuple &args, const Dict &kw ) const; + + Object getItem( const Object &key ) const + { + return Object( PyObject_GetItem( p, *key ), true ); + } + + long hashValue() const + { + return PyObject_Hash( p ); + } + + // convert to bool + bool as_bool() const + { + return PyObject_IsTrue( ptr() ) != 0; + } + + //operator bool() const + //{ + // return as_bool(); + //} + + // int print( FILE *fp, int flags=Py_Print_RAW ) + //{ + // return PyObject_Print( p, fp, flags ); + //} + + bool is( PyObject *pother ) const + { // identity test + return p == pother; + } + + bool is( const Object &other ) const + { // identity test + return p == other.p; + } + + bool isNull() const + { + return p == NULL; + } + + bool isNone() const + { + return p == _None(); + } + + bool isCallable() const + { + return PyCallable_Check( p ) != 0; + } + + bool isDict() const + { + return Py::_Dict_Check( p ); + } + + bool isList() const + { + return Py::_List_Check( p ); + } + + bool isMapping() const + { + return PyMapping_Check( p ) != 0; + } + + bool isNumeric() const + { + return PyNumber_Check( p ) != 0; + } + + bool isSequence() const + { + return PySequence_Check( p ) != 0; + } + + bool isTrue() const + { + return PyObject_IsTrue( p ) != 0; + } + + bool isType( const Type &t ) const; + + bool isTuple() const + { + return Py::_Tuple_Check( p ); + } + + bool isString() const + { + return Py::_Unicode_Check( p ); + } + + bool isBytes() const + { + return Py::_Bytes_Check( p ); + } + + bool isBoolean() const + { + return Py::_Boolean_Check( p ); + } + + // Commands + void setAttr( const std::string &s, const Object &value ) + { + if( PyObject_SetAttrString( p, const_cast( s.c_str() ), *value ) == -1 ) + throw AttributeError( "getAttr failed." ); + } + + void delAttr( const std::string &s ) + { + if( PyObject_DelAttrString( p, const_cast( s.c_str() ) ) == -1 ) + throw AttributeError( "delAttr failed." ); + } + + // PyObject_SetItem is too weird to be using from C++ + // so it is intentionally omitted. + + void delItem( const Object &key ) + { + //if( PyObject_DelItem( p, *key ) == -1 ) + // failed to link on Windows? + throw KeyError( "delItem failed." ); + } + // Equality and comparison use PyObject_Compare + + }; + // End of class Object + + // Null can be return from when it is require to return NULL to Python from a method + class Null: public Object + { + public: + Null() + : Object( NULL ) + { + } + virtual ~Null() + { + } + + virtual bool accepts( PyObject *pyob ) + { + return pyob == NULL; + } + }; + + //------------------------------------------------------------ + bool operator==( const Object &o1, const Object &o2 ); + bool operator!=( const Object &o1, const Object &o2 ); + bool operator>=( const Object &o1, const Object &o2 ); + bool operator<=( const Object &o1, const Object &o2 ); + bool operator<( const Object &o1, const Object &o2 ); + bool operator>( const Object &o1, const Object &o2 ); + + //------------------------------------------------------------ + + + // + // Convert an owned Python pointer into a PyCXX Object + // + inline Object asObject( PyObject *p ) + { + return Object( p, true ); + } + + // new_reference_to also overloaded below on Object + inline PyObject *new_reference_to( PyObject *p ) + { + Py::_XINCREF( p ); + return p; + } + + inline PyObject *new_reference_to( const Object &g ) + { + PyObject *p = g.ptr(); + Py::_XINCREF( p ); + return p; + } + + // Python special None value + inline Object None() + { + return Object( Py::_None() ); + } + + // Python special Boolean values + inline Object False() + { + return Object( Py::_False() ); + } + + inline Object True() + { + return Object( Py::_True() ); + } + + // TMM: 31May'01 - Added the #ifndef so I can exlude iostreams. +#ifndef CXX_NO_IOSTREAMS + std::ostream &operator<<( std::ostream &os, const Object &ob ); +#endif + + // Class Type + class Type: public Object + { + public: + explicit Type( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Type( const Object &ob ) + : Object( *ob ) + { + validate(); + } + + Type( const Type &t ) + : Object( t ) + { + validate(); + } + + Type &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Type &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Type_Check( pyob ); + } + }; + + // =============================================== + // class boolean + class Boolean: public Object + { + public: + // Constructor + Boolean( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Boolean( const Boolean &ob ) + : Object( *ob ) + { + validate(); + } + + // create from bool + Boolean( bool v=false ) + { + set( PyBool_FromLong( v ? 1 : 0 ), true ); + validate(); + } + + explicit Boolean( const Object &ob ) + : Object( *ob ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + Boolean &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Boolean &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + // accepts any object that can be converted to a boolean + return pyob && PyObject_IsTrue( pyob ) != -1; + } + + Boolean &operator=( bool v ) + { + set( PyBool_FromLong( v ? 1 : 0 ), true ); + return *this; + } + + operator bool() const + { + return as_bool(); + } + }; + + // =============================================== + // class Long + class Long: public Object + { + public: + // Constructor + explicit Long( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Long( const Long &ob ) + : Object( ob.ptr() ) + { + validate(); + } + + // try to create from any object + explicit Long( const Object &ob ) + : Object( PyNumber_Long( *ob ), true ) + { + validate(); + } + + // create from long + explicit Long( long v = 0L ) + : Object( PyLong_FromLong( v ), true ) + { + validate(); + } + + // create from unsigned long + explicit Long( unsigned long v ) + : Object( PyLong_FromUnsignedLong( v ), true ) + { + validate(); + } + + // create from int + explicit Long( int v ) + : Object( PyLong_FromLong( static_cast( v ) ), true ) + { + validate(); + } + +#ifdef HAVE_LONG_LONG + // create from long long + explicit Long( PY_LONG_LONG v ) + : Object( PyLong_FromLongLong( v ), true ) + { + validate(); + } + + // create from unsigned long long + explicit Long( unsigned PY_LONG_LONG v ) + : Object( PyLong_FromUnsignedLongLong( v ), true ) + { + validate(); + } +#endif + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Long_Check( pyob ); + } + + // Assignment acquires new ownership of pointer + Long &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Long &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( PyNumber_Long( rhsp ), true ); + return *this; + } + + // assign from an int + Long &operator=( int v ) + { + set( PyLong_FromLong( long( v ) ), true ); + return *this; + } + + // assign from long + Long &operator=( long v ) + { + set( PyLong_FromLong( v ), true ); + return *this; + } + + // assign from unsigned long + Long &operator=( unsigned long v ) + { + set( PyLong_FromUnsignedLong( v ), true ); + return *this; + } + +#ifdef HAVE_LONG_LONG + Long &operator=( PY_LONG_LONG v ) + { + set( PyLong_FromLongLong( v ), true ); + return *this; + } + + Long &operator=( unsigned PY_LONG_LONG v ) + { + set( PyLong_FromUnsignedLongLong( v ), true ); + return *this; + } +#endif + + //operator bool() const + //{ + // return as_bool(); + //} + + // convert to long + long as_long() const + { + return PyLong_AsLong( ptr() ); + } + + operator long() const + { + return as_long(); + } + + operator int() const + { + return static_cast( as_long() ); + } + + // convert to unsigned + long as_unsigned_long() const + { + return PyLong_AsUnsignedLong( ptr() ); + } + + operator unsigned long() const + { + return as_unsigned_long(); + } + + double as_double() const + { + return PyLong_AsDouble( ptr() ); + } + + operator double() const + { + return as_double(); + } + +#ifdef HAVE_LONG_LONG + PY_LONG_LONG as_long_long() const + { + return PyLong_AsLongLong( ptr() ); + } + + operator PY_LONG_LONG() const + { + return as_long_long(); + } + + unsigned PY_LONG_LONG as_unsigned_long_long() const + { + return PyLong_AsUnsignedLongLong( ptr() ); + } + + operator unsigned PY_LONG_LONG() const + { + return as_unsigned_long_long(); + } +#endif + + // prefix ++ + Long operator++() + { + set( PyNumber_Add( ptr(), *Long( 1 ) ) ); + return *this; + } + + // postfix ++ + Long operator++( int ) + { + Long a = *this; + set( PyNumber_Add( ptr(), *Long( 1 ) ) ); + return a; + } + + // prefix -- + Long operator--() + { + set( PyNumber_Subtract( ptr(), *Long( 1 ) ) ); + return *this; + } + + // postfix -- + Long operator--( int ) + { + Long a = *this; + set( PyNumber_Subtract( ptr(), *Long( 1 ) ) ); + return a; + } + }; + +#ifdef PYCXX_PYTHON_2TO3 + // PyCXX for Python2 had an Int and LongLong classes + typedef Long Int; +#ifdef HAVE_LONG_LONG + typedef Long LongLong; +#endif +#endif + +#if 1 + //------------------------------------------------------------ + // compare operators + bool operator!=( const Long &a, const Long &b ); + bool operator!=( const Long &a, int b ); + bool operator!=( const Long &a, long b ); + bool operator!=( int a, const Long &b ); + bool operator!=( long a, const Long &b ); + //------------------------------ + bool operator==( const Long &a, const Long &b ); + bool operator==( const Long &a, int b ); + bool operator==( const Long &a, long b ); + bool operator==( int a, const Long &b ); + bool operator==( long a, const Long &b ); + //------------------------------ + bool operator>( const Long &a, const Long &b ); + bool operator>( const Long &a, int b ); + bool operator>( const Long &a, long b ); + bool operator>( int a, const Long &b ); + bool operator>( long a, const Long &b ); + //------------------------------ + bool operator>=( const Long &a, const Long &b ); + bool operator>=( const Long &a, int b ); + bool operator>=( const Long &a, long b ); + bool operator>=( int a, const Long &b ); + bool operator>=( long a, const Long &b ); + //------------------------------ + bool operator<( const Long &a, const Long &b ); + bool operator<( const Long &a, int b ); + bool operator<( const Long &a, long b ); + bool operator<( int a, const Long &b ); + bool operator<( long a, const Long &b ); + //------------------------------ + bool operator<=( const Long &a, const Long &b ); + bool operator<=( int a, const Long &b ); + bool operator<=( long a, const Long &b ); + bool operator<=( const Long &a, int b ); + bool operator<=( const Long &a, long b ); + +#ifdef HAVE_LONG_LONG + //------------------------------ + bool operator!=( const Long &a, PY_LONG_LONG b ); + bool operator!=( PY_LONG_LONG a, const Long &b ); + //------------------------------ + bool operator==( const Long &a, PY_LONG_LONG b ); + bool operator==( PY_LONG_LONG a, const Long &b ); + //------------------------------ + bool operator>( const Long &a, PY_LONG_LONG b ); + bool operator>( PY_LONG_LONG a, const Long &b ); + //------------------------------ + bool operator>=( const Long &a, PY_LONG_LONG b ); + bool operator>=( PY_LONG_LONG a, const Long &b ); + //------------------------------ + bool operator<( const Long &a, PY_LONG_LONG b ); + bool operator<( PY_LONG_LONG a, const Long &b ); + //------------------------------ + bool operator<=( const Long &a, PY_LONG_LONG b ); + bool operator<=( PY_LONG_LONG a, const Long &b ); +#endif +#endif + + // =============================================== + // class Float + // + class Float: public Object + { + public: + // Constructor + explicit Float( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Float( const Float &f ) + : Object( f ) + { + validate(); + } + + // make from double + explicit Float( double v=0.0 ) + : Object( PyFloat_FromDouble( v ), true ) + { + validate(); + } + + // try to make from any object + Float( const Object &ob ) + : Object( PyNumber_Float( *ob ), true ) + { + validate(); + } + + Float &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Float &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( PyNumber_Float( rhsp ), true ); + return *this; + } + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Float_Check( pyob ); + } + + double as_double() const + { + return PyFloat_AsDouble( ptr() ); + } + + // convert to double + operator double() const + { + return as_double(); + } + + // assign from a double + Float &operator=( double v ) + { + set( PyFloat_FromDouble( v ), true ); + return *this; + } + // assign from an int + Float &operator=( int v ) + { + set( PyFloat_FromDouble( double( v ) ), true ); + return *this; + } + // assign from long + Float &operator=( long v ) + { + set( PyFloat_FromDouble( double( v ) ), true ); + return *this; + } + // assign from an Long + Float &operator=( const Long &iob ) + { + set( PyFloat_FromDouble( double( iob.as_long() ) ), true ); + return *this; + } + }; + + //------------------------------------------------------------ + // compare operators + bool operator!=( const Float &a, const Float &b ); + bool operator!=( const Float &a, double b ); + bool operator!=( double a, const Float &b ); + //------------------------------ + bool operator==( const Float &a, const Float &b ); + bool operator==( const Float &a, double b ); + bool operator==( double a, const Float &b ); + //------------------------------ + bool operator>( const Float &a, const Float &b ); + bool operator>( const Float &a, double b ); + bool operator>( double a, const Float &b ); + //------------------------------ + bool operator>=( const Float &a, const Float &b ); + bool operator>=( const Float &a, double b ); + bool operator>=( double a, const Float &b ); + //------------------------------ + bool operator<( const Float &a, const Float &b ); + bool operator<( const Float &a, double b ); + bool operator<( double a, const Float &b ); + //------------------------------ + bool operator<=( const Float &a, const Float &b ); + bool operator<=( double a, const Float &b ); + bool operator<=( const Float &a, double b ); + + // =============================================== + // class Complex + class Complex: public Object + { + public: + // Constructor + explicit Complex( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Complex( const Complex &f ) + : Object( f ) + { + validate(); + } + + // make from double + explicit Complex( double v=0.0, double w=0.0 ) + :Object( PyComplex_FromDoubles( v, w ), true ) + { + validate(); + } + + Complex &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Complex &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Complex_Check( pyob ); + } + // convert to Py_complex + operator Py_complex() const + { + return PyComplex_AsCComplex( ptr() ); + } + // assign from a Py_complex + Complex &operator=( const Py_complex &v ) + { + set( PyComplex_FromCComplex( v ), true ); + return *this; + } + // assign from a double + Complex &operator=( double v ) + { + set( PyComplex_FromDoubles( v, 0.0 ), true ); + return *this; + } + // assign from an int + Complex &operator=( int v ) + { + set( PyComplex_FromDoubles( double( v ), 0.0 ), true ); + return *this; + } + // assign from long + Complex &operator=( long v ) + { + set( PyComplex_FromDoubles( double( v ), 0.0 ), true ); + return *this; + } + // assign from an Long + Complex &operator=( const Long &iob ) + { + set( PyComplex_FromDoubles( double( iob.as_long() ), 0.0 ), true ); + return *this; + } + + double real() const + { + return PyComplex_RealAsDouble( ptr() ); + } + + double imag() const + { + return PyComplex_ImagAsDouble( ptr() ); + } + }; + // Sequences + // Sequences are here represented as sequences of items of type T. + // The base class SeqBase represents that. + // In basic Python T is always "Object". + + // seqref is what you get if you get elements from a non-const SeqBase. + // Note: seqref could probably be a nested class in SeqBase but that might stress + // some compilers needlessly. Simlarly for mapref later. + + // While this class is not intended for enduser use, it needs some public + // constructors for the benefit of the STL. + + // See Scott Meyer's More Essential C++ for a description of proxies. + // This application is even more complicated. We are doing an unusual thing + // in having a double proxy. If we want the STL to work + // properly we have to compromise by storing the rvalue inside. The + // entire Object API is repeated so that things like s[i].isList() will + // work properly. + + // Still, once in a while a weird compiler message may occur using expressions like x[i] + // Changing them to Object( x[i] ) helps the compiler to understand that the + // conversion of a seqref to an Object is wanted. + + template + class seqref + { + protected: + SeqBase &s; // the sequence + int offset; // item number + T the_item; // lvalue + + public: + seqref( SeqBase &seq, sequence_index_type j ) + : s( seq ) + , offset( j ) + , the_item( s.getItem( j ) ) + {} + + seqref( const seqref &range ) + : s( range.s ) + , offset( range.offset ) + , the_item( range.the_item ) + {} + + // TMM: added this seqref ctor for use with STL algorithms + seqref( Object &obj ) + : s( dynamic_cast< SeqBase&>( obj ) ) + , offset( NULL ) + , the_item( s.getItem( offset ) ) + {} + + ~seqref() + {} + + operator T() const + { // rvalue + return the_item; + } + + seqref &operator=( const seqref &rhs ) + { //used as lvalue + the_item = rhs.the_item; + s.setItem( offset, the_item ); + return *this; + } + + seqref &operator=( const T &ob ) + { // used as lvalue + the_item = ob; + s.setItem( offset, ob ); + return *this; + } + + // forward everything else to the item + PyObject *ptr() const + { + return the_item.ptr(); + } + + int reference_count() const + { // the reference count + return the_item.reference_count(); + } + + Type type() const + { + return the_item.type(); + } + + String str() const; + String repr() const; + + bool hasAttr( const std::string &attr_name ) const + { + return the_item.hasAttr( attr_name ); + } + + Object getAttr( const std::string &attr_name ) const + { + return the_item.getAttr( attr_name ); + } + + Object getItem( const Object &key ) const + { + return the_item.getItem( key ); + } + + long hashValue() const + { + return the_item.hashValue(); + } + + bool isCallable() const + { + return the_item.isCallable(); + } + + bool isInstance() const + { + return the_item.isInstance(); + } + + bool isDict() const + { + return the_item.isDict(); + } + + bool isList() const + { + return the_item.isList(); + } + + bool isMapping() const + { + return the_item.isMapping(); + } + + bool isNumeric() const + { + return the_item.isNumeric(); + } + + bool isSequence() const + { + return the_item.isSequence(); + } + + bool isTrue() const + { + return the_item.isTrue(); + } + + bool isType( const Type &t ) const + { + return the_item.isType( t ); + } + + bool isTuple() const + { + return the_item.isTuple(); + } + + bool isString() const + { + return the_item.isString(); + } + // Commands + void setAttr( const std::string &attr_name, const Object &value ) + { + the_item.setAttr( attr_name, value ); + } + + void delAttr( const std::string &attr_name ) + { + the_item.delAttr( attr_name ); + } + + void delItem( const Object &key ) + { + the_item.delItem( key ); + } + + bool operator==( const Object &o2 ) const + { + return the_item == o2; + } + + bool operator!=( const Object &o2 ) const + { + return the_item != o2; + } + + bool operator>=( const Object &o2 ) const + { + return the_item >= o2; + } + + bool operator<=( const Object &o2 ) const + { + return the_item <= o2; + } + + bool operator<( const Object &o2 ) const + { + return the_item < o2; + } + + bool operator>( const Object &o2 ) const + { + return the_item > o2; + } + }; // end of seqref + + + // class SeqBase + // ...the base class for all sequence types + + template + class SeqBase: public Object + { + public: + // STL definitions + typedef size_t size_type; + typedef seqref reference; + typedef T const_reference; + typedef seqref *pointer; + typedef int difference_type; + typedef T value_type; // TMM: 26Jun'01 + + virtual size_type max_size() const + { + return std::string::npos; // ? + } + + virtual size_type capacity() const + { + return size(); + } + + virtual void swap( SeqBase &c ) + { + SeqBase temp = c; + c = ptr(); + set( temp.ptr() ); + } + + virtual size_type size() const + { + return PySequence_Length( ptr() ); + } + + explicit SeqBase() + :Object( PyTuple_New( 0 ), true ) + { + validate(); + } + + explicit SeqBase( PyObject *pyob, bool owned=false ) + : Object( pyob, owned ) + { + validate(); + } + + SeqBase( const Object &ob ) + : Object( ob ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + SeqBase &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + SeqBase &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + virtual bool accepts( PyObject *pyob ) const + { + return pyob && PySequence_Check( pyob ); + } + + size_type length() const + { + return PySequence_Length( ptr() ); + } + + // Element access + const T operator[]( sequence_index_type index ) const + { + return getItem( index ); + } + + seqref operator[]( sequence_index_type index ) + { + return seqref( *this, index ); + } + + virtual T getItem( sequence_index_type i ) const + { + return T( asObject( PySequence_GetItem( ptr(), i ) ) ); + } + + virtual void setItem( sequence_index_type i, const T &ob ) + { + if( PySequence_SetItem( ptr(), i, *ob ) == -1 ) + { + throw Exception(); + } + } + + SeqBase repeat( int count ) const + { + return SeqBase( PySequence_Repeat( ptr(), count ), true ); + } + + SeqBase concat( const SeqBase &other ) const + { + return SeqBase( PySequence_Concat( ptr(), *other ), true ); + } + + // more STL compatability + const T front() const + { + return getItem( 0 ); + } + + seqref front() + { + return seqref( *this, 0 ); + } + + const T back() const + { + return getItem( size()-1 ); + } + + seqref back() + { + return seqref( *this, size()-1 ); + } + + void verify_length( size_type required_size ) const + { + if( size() != required_size ) + throw IndexError( "Unexpected SeqBase length." ); + } + + void verify_length( size_type min_size, size_type max_size ) const + { + size_type n = size(); + if( n < min_size || n > max_size ) + throw IndexError( "Unexpected SeqBase length." ); + } + + class iterator + : public random_access_iterator_parent( seqref ) + { + protected: + friend class SeqBase; + SeqBase *seq; + int count; + + public: + ~iterator() + {} + + iterator() + : seq( 0 ) + , count( 0 ) + {} + + iterator( SeqBase *s, int where ) + : seq( s ) + , count( where ) + {} + + iterator( const iterator &other ) + : seq( other.seq ) + , count( other.count ) + {} + + bool eql( const iterator &other ) const + { + return seq->ptr() == other.seq->ptr() && count == other.count; + } + + bool neq( const iterator &other ) const + { + return seq->ptr() != other.seq->ptr() || count != other.count; + } + + bool lss( const iterator &other ) const + { + return count < other.count; + } + + bool gtr( const iterator &other ) const + { + return count > other.count; + } + + bool leq( const iterator &other ) const + { + return count <= other.count; + } + + bool geq( const iterator &other ) const + { + return count >= other.count; + } + + seqref operator*() + { + return seqref( *seq, count ); + } + + seqref operator[]( sequence_index_type i ) + { + return seqref( *seq, count + i ); + } + + iterator &operator=( const iterator &other ) + { + if( this != &other ) + { + seq = other.seq; + count = other.count; + } + return *this; + } + + iterator operator+( int n ) const + { + return iterator( seq, count + n ); + } + + iterator operator-( int n ) const + { + return iterator( seq, count - n ); + } + + iterator &operator+=( int n ) + { + count = count + n; + return *this; + } + + iterator &operator-=( int n ) + { + count = count - n; + return *this; + } + + int operator-( const iterator &other ) const + { + if( seq->ptr() != other.seq->ptr() ) + throw RuntimeError( "SeqBase::iterator comparison error" ); + + return count - other.count; + } + + // prefix ++ + iterator &operator++() + { + count++; + return *this; + } + + // postfix ++ + iterator operator++( int ) + { + return iterator( seq, count++ ); + } + + // prefix -- + iterator &operator--() + { + count--; + return *this; + } + + // postfix -- + iterator operator--( int ) + { + return iterator( seq, count-- ); + } + + std::string diagnose() const + { + std::OSTRSTREAM oss; + oss << "iterator diagnosis " << seq << ", " << count << std::ends; + return std::string( oss.str() ); + } + + }; // end of class SeqBase::iterator + + iterator begin() + { + return iterator( this, 0 ); + } + + iterator end() + { + return iterator( this, length() ); + } + + class const_iterator + : public random_access_iterator_parent( const Object ) + { + protected: + friend class SeqBase; + const SeqBase *seq; + sequence_index_type count; + + public: + ~const_iterator() + {} + + const_iterator() + : seq( 0 ) + , count( 0 ) + {} + + const_iterator( const SeqBase *s, int where ) + : seq( s ) + , count( where ) + {} + + const_iterator( const const_iterator &other ) + : seq( other.seq ) + , count( other.count ) + {} + + const T operator*() const + { + return seq->getItem( count ); + } + + const T operator[]( sequence_index_type i ) const + { + return seq->getItem( count + i ); + } + + const_iterator &operator=( const const_iterator &other ) + { + if( this != &other ) + { + seq = other.seq; + count = other.count; + } + return *this; + } + + const_iterator operator+( int n ) const + { + return const_iterator( seq, count + n ); + } + + bool eql( const const_iterator &other ) const + { + return seq->ptr() == other.seq->ptr() && count == other.count; + } + + bool neq( const const_iterator &other ) const + { + return seq->ptr() != other.seq->ptr() || count != other.count; + } + + bool lss( const const_iterator &other ) const + { + return count < other.count; + } + + bool gtr( const const_iterator &other ) const + { + return count > other.count; + } + + bool leq( const const_iterator &other ) const + { + return count <= other.count; + } + + bool geq( const const_iterator &other ) const + { + return count >= other.count; + } + + const_iterator operator-( int n ) + { + return const_iterator( seq, count - n ); + } + + const_iterator &operator+=( int n ) + { + count = count + n; + return *this; + } + + const_iterator &operator-=( int n ) + { + count = count - n; + return *this; + } + + int operator-( const const_iterator &other ) const + { + if( *seq != *other.seq ) + throw RuntimeError( "SeqBase::const_iterator::- error" ); + return count - other.count; + } + + // prefix ++ + const_iterator &operator++() + { + count++; + return *this; + } + + // postfix ++ + const_iterator operator++( int ) + { + return const_iterator( seq, count++ ); + } + + // prefix -- + const_iterator &operator--() + { + count--; + return *this; + } + + // postfix -- + const_iterator operator--( int ) + { + return const_iterator( seq, count-- ); + } + + }; // end of class SeqBase::const_iterator + + const_iterator begin() const + { + return const_iterator( this, 0 ); + } + + const_iterator end() const + { + return const_iterator( this, length() ); + } + }; + + // Here's an important typedef you might miss if reading too fast... + typedef SeqBase Sequence; + + template bool operator==( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + template bool operator!=( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + template bool operator< ( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + template bool operator> ( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + template bool operator<=( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + template bool operator>=( const EXPLICIT_TYPENAME SeqBase::iterator &left, const EXPLICIT_TYPENAME SeqBase::iterator &right ); + + template bool operator==( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + template bool operator!=( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + template bool operator< ( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + template bool operator> ( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + template bool operator<=( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + template bool operator>=( const EXPLICIT_TYPENAME SeqBase::const_iterator &left, const EXPLICIT_TYPENAME SeqBase::const_iterator &right ); + + + extern bool operator==( const Sequence::iterator &left, const Sequence::iterator &right ); + extern bool operator!=( const Sequence::iterator &left, const Sequence::iterator &right ); + extern bool operator< ( const Sequence::iterator &left, const Sequence::iterator &right ); + extern bool operator> ( const Sequence::iterator &left, const Sequence::iterator &right ); + extern bool operator<=( const Sequence::iterator &left, const Sequence::iterator &right ); + extern bool operator>=( const Sequence::iterator &left, const Sequence::iterator &right ); + + extern bool operator==( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + extern bool operator!=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + extern bool operator< ( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + extern bool operator> ( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + extern bool operator<=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + extern bool operator>=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ); + + // ================================================== + // class Char + // Python strings return strings as individual elements. + // I'll try having a class Char which is a String of length 1 + // + typedef std::basic_string unicodestring; + extern Py_UNICODE unicode_null_string[1]; + + class Byte: public Object + { + public: + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob != NULL + && Py::_Unicode_Check( pyob ) + && PySequence_Length( pyob ) == 1; + } + + explicit Byte( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Byte( const Object &ob ) + : Object( ob ) + { + validate(); + } + + Byte( const std::string &v = "" ) + : Object( PyBytes_FromStringAndSize( const_cast( v.c_str() ), 1 ), true ) + { + validate(); + } + + Byte( char v ) + : Object( PyBytes_FromStringAndSize( &v, 1 ), true ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + Byte &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Byte &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + // Assignment from C string + Byte &operator=( const std::string &v ) + { + set( PyBytes_FromStringAndSize( const_cast( v.c_str() ),1 ), true ); + return *this; + } + + Byte &operator=( char v ) + { + set( PyUnicode_FromStringAndSize( &v, 1 ), true ); + return *this; + } + + // Conversion + operator Bytes() const; + }; + + class Bytes: public SeqBase + { + public: + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob != NULL && Py::_Bytes_Check( pyob ); + } + + virtual size_type capacity() const + { + return max_size(); + } + + explicit Bytes( PyObject *pyob, bool owned = false ) + : SeqBase( pyob, owned ) + { + validate(); + } + + Bytes( const Object &ob ) + : SeqBase( ob ) + { + validate(); + } + + Bytes() + : SeqBase( PyBytes_FromStringAndSize( "", 0 ), true ) + { + validate(); + } + + Bytes( const std::string &v ) + : SeqBase( PyBytes_FromStringAndSize( const_cast( v.data() ), static_cast( v.length() ) ), true ) + { + validate(); + } + + Bytes( const std::string &v, Py_ssize_t vsize ) + : SeqBase( PyBytes_FromStringAndSize( const_cast( v.data() ), static_cast( vsize ) ), true ) + { + validate(); + } + + Bytes( const char *v ) + : SeqBase( PyBytes_FromString( v ), true ) + { + validate(); + } + + Bytes( const char *v, Py_ssize_t vsize ) + : SeqBase( PyBytes_FromStringAndSize( const_cast( v ), vsize ), true ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + Bytes &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Bytes &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + // Assignment from C string + Bytes &operator=( const std::string &v ) + { + set( PyBytes_FromStringAndSize( const_cast( v.data() ), static_cast( v.length() ) ), true ); + return *this; + } + + String decode( const char *encoding, const char *error="strict" ); + + // Queries + virtual size_type size() const + { + return static_cast( PyBytes_Size( ptr() ) ); + } + + operator std::string() const + { + return as_std_string(); + } + + std::string as_std_string() const + { + return std::string( PyBytes_AsString( ptr() ), static_cast( PyBytes_Size( ptr() ) ) ); + } + }; + + class Char: public Object + { + public: + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob != 0 &&( Py::_Unicode_Check( pyob ) ) && PySequence_Length( pyob ) == 1; + } + + explicit Char( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Char( const Object &ob ) + : Object( ob ) + { + validate(); + } + + Char( int v ) + : Object( PyUnicode_FromOrdinal( v ), true ) + { + validate(); + } + + Char( Py_UNICODE v ) + : Object( PyUnicode_FromOrdinal( v ), true ) + { + validate(); + } + + Char( const unicodestring &v ) + : Object( PyUnicode_FromUnicode( const_cast( v.data() ),1 ), true ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + Char &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Char &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + Char &operator=( const unicodestring &v ) + { + set( PyUnicode_FromUnicode( const_cast( v.data() ), 1 ), true ); + return *this; + } + + Char &operator=( int v_ ) + { + Py_UNICODE v( v_ ); + set( PyUnicode_FromUnicode( &v, 1 ), true ); + return *this; + } + + Char &operator=( Py_UNICODE v ) + { + set( PyUnicode_FromUnicode( &v, 1 ), true ); + return *this; + } + + // Conversion + operator String() const; + }; + + class String: public SeqBase + { + public: + virtual size_type capacity() const + { + return max_size(); + } + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob != NULL && Py::_Unicode_Check( pyob ); + } + + explicit String( PyObject *pyob, bool owned = false ) + : SeqBase( pyob, owned ) + { + validate(); + } + + String( const Object &ob ) + : SeqBase( ob ) + { + validate(); + } + + String() + : SeqBase( PyUnicode_FromString( "" ) ) + { + validate(); + } + + String( const char *latin1 ) + : SeqBase( PyUnicode_FromString( latin1 ) ) + { + validate(); + } + + String( const std::string &latin1 ) + : SeqBase( PyUnicode_FromStringAndSize( latin1.c_str(), latin1.size() ) ) + { + validate(); + } + + String( const char *latin1, Py_ssize_t size ) + : SeqBase( PyUnicode_FromStringAndSize( latin1, size ) ) + { + validate(); + } + + /* [Taken from Pythons's unicode.h] + + Many of these APIs take two arguments encoding and errors. These + parameters encoding and errors have the same semantics as the ones + of the builtin unicode() API. + + Setting encoding to NULL causes the default encoding to be used. + + Error handling is set by errors which may also be set to NULL + meaning to use the default handling defined for the codec. Default + error handling for all builtin codecs is "strict" (ValueErrors are + raised). + + The codecs all use a similar interface. Only deviation from the + generic ones are documented. + + */ + String( const std::string &s, const char *encoding, const char *errors=NULL ) + : SeqBase( PyUnicode_Decode( s.c_str(), s.size(), encoding, errors ), true ) + { + validate(); + } + + String( const char *s, const char *encoding, const char *errors=NULL ) + : SeqBase( PyUnicode_Decode( s, strlen(s), encoding, errors ), true ) + { + validate(); + } + + String( const char *s, Py_ssize_t size, const char *encoding, const char *errors=NULL ) + : SeqBase( PyUnicode_Decode( s, size, encoding, errors ), true ) + { + validate(); + } + + String( const Py_UNICODE *s, int length ) + : SeqBase( PyUnicode_FromUnicode( s, length ), true ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + String &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + String &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + String &operator=( const unicodestring &v ) + { + set( PyUnicode_FromUnicode( const_cast( v.data() ), static_cast( v.length() ) ), true ); + return *this; + } + + // Encode + Bytes encode( const char *encoding, const char *error="strict" ) const + { + return Bytes( PyUnicode_AsEncodedString( ptr(), encoding, error ), true ); + } + + // Queries + virtual size_type size() const + { + return static_cast( PyUnicode_GET_SIZE( ptr() ) ); + } + + unicodestring as_unicodestring() const + { + return unicodestring( PyUnicode_AS_UNICODE( ptr() ), static_cast( PyUnicode_GET_SIZE( ptr() ) ) ); + } + + operator std::string() const + { + // use the default encoding + return as_std_string( NULL ); + } + + std::string as_std_string( const char *encoding=NULL, const char *error="strict" ) const + { + Bytes b( encode( encoding, error ) ); + return b.as_std_string(); + } + + const Py_UNICODE *unicode_data() const + { + return PyUnicode_AS_UNICODE( ptr() ); + } + }; + + // ================================================== + // class Tuple + class Tuple: public Sequence + { + public: + virtual void setItem( sequence_index_type offset, const Object&ob ) + { + // note PyTuple_SetItem is a thief... + if( PyTuple_SetItem( ptr(), offset, new_reference_to( ob ) ) == -1 ) + { + throw Exception(); + } + } + + // Constructor + explicit Tuple( PyObject *pyob, bool owned = false ) + : Sequence( pyob, owned ) + { + validate(); + } + + Tuple( const Object &ob ) + : Sequence( ob ) + { + validate(); + } + + // New tuple of a given size + explicit Tuple( int size = 0 ) + { + set( PyTuple_New( size ), true ); + validate(); + for( sequence_index_type i=0; i < size; i++ ) + { + if( PyTuple_SetItem( ptr(), i, new_reference_to( Py::_None() ) ) == -1 ) + { + throw Exception(); + } + } + } + // Tuple from any sequence + explicit Tuple( const Sequence &s ) + { + sequence_index_type limit( sequence_index_type( s.length() ) ); + + set( PyTuple_New( limit ), true ); + validate(); + + for( sequence_index_type i=0; i < limit; i++ ) + { + if( PyTuple_SetItem( ptr(), i, new_reference_to( s[i] ) ) == -1 ) + { + throw Exception(); + } + } + } + + // Assignment acquires new ownership of pointer + Tuple &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Tuple &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Tuple_Check( pyob ); + } + + Tuple getSlice( int i, int j ) const + { + return Tuple( PySequence_GetSlice( ptr(), i, j ), true ); + } + + }; + + class TupleN: public Tuple + { + public: + TupleN() + : Tuple( 0 ) + { + } + + TupleN( const Object &obj1 ) + : Tuple( 1 ) + { + setItem( 0, obj1 ); + } + + TupleN( const Object &obj1, const Object &obj2 ) + : Tuple( 2 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3 ) + : Tuple( 3 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4 ) + : Tuple( 4 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4, const Object &obj5 ) + : Tuple( 5 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + setItem( 4, obj5 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4, const Object &obj5, const Object &obj6 ) + : Tuple( 6 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + setItem( 4, obj5 ); + setItem( 5, obj6 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4, const Object &obj5, const Object &obj6, + const Object &obj7 ) + : Tuple( 7 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + setItem( 4, obj5 ); + setItem( 5, obj6 ); + setItem( 6, obj7 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4, const Object &obj5, const Object &obj6, + const Object &obj7, const Object &obj8 ) + : Tuple( 8 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + setItem( 4, obj5 ); + setItem( 5, obj6 ); + setItem( 6, obj7 ); + setItem( 7, obj8 ); + } + + TupleN( const Object &obj1, const Object &obj2, const Object &obj3, + const Object &obj4, const Object &obj5, const Object &obj6, + const Object &obj7, const Object &obj8, const Object &obj9 ) + : Tuple( 9 ) + { + setItem( 0, obj1 ); + setItem( 1, obj2 ); + setItem( 2, obj3 ); + setItem( 3, obj4 ); + setItem( 4, obj5 ); + setItem( 5, obj6 ); + setItem( 6, obj7 ); + setItem( 7, obj8 ); + setItem( 8, obj9 ); + } + + virtual ~TupleN() + { } + }; + + // ================================================== + // class List + + class List: public Sequence + { + public: + // Constructor + explicit List( PyObject *pyob, bool owned = false ) + : Sequence( pyob, owned ) + { + validate(); + } + List( const Object &ob ) + : Sequence( ob ) + { + validate(); + } + // Creation at a fixed size + List( int size = 0 ) + { + set( PyList_New( size ), true ); + validate(); + for( sequence_index_type i=0; i < size; i++ ) + { + if( PyList_SetItem( ptr(), i, new_reference_to( Py::_None() ) ) == -1 ) + { + throw Exception(); + } + } + } + + // List from a sequence + List( const Sequence &s ) + : Sequence() + { + int n =( int )s.length(); + set( PyList_New( n ), true ); + validate(); + for( sequence_index_type i=0; i < n; i++ ) + { + if( PyList_SetItem( ptr(), i, new_reference_to( s[i] ) ) == -1 ) + { + throw Exception(); + } + } + } + + virtual size_type capacity() const + { + return max_size(); + } + + // Assignment acquires new ownership of pointer + List &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + List &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_List_Check( pyob ); + } + + List getSlice( int i, int j ) const + { + return List( PyList_GetSlice( ptr(), i, j ), true ); + } + + void setSlice( int i, int j, const Object &v ) + { + if( PyList_SetSlice( ptr(), i, j, *v ) == -1 ) + { + throw Exception(); + } + } + + void append( const Object &ob ) + { + if( PyList_Append( ptr(), *ob ) == -1 ) + { + throw Exception(); + } + } + + void extend( const Object &ob ) + { + setSlice( size(), size(), ob ); + } + + void insert( int i, const Object &ob ) + { + if( PyList_Insert( ptr(), i, *ob ) == -1 ) + { + throw Exception(); + } + } + + void sort() + { + if( PyList_Sort( ptr() ) == -1 ) + { + throw Exception(); + } + } + + void reverse() + { + if( PyList_Reverse( ptr() ) == -1 ) + { + throw Exception(); + } + } + }; + + + // Mappings + // ================================================== + template + class mapref + { + protected: + MapBase &s; // the map + Object key; // item key + T the_item; + + public: + mapref( MapBase &map, const std::string &k ) + : s( map ), the_item() + { + key = String( k ); + if( map.hasKey( key ) ) the_item = map.getItem( key ); + } + + mapref( MapBase &map, const Object &k ) + : s( map ), key( k ), the_item() + { + if( map.hasKey( key ) ) the_item = map.getItem( key ); + } + + virtual ~mapref() + {} + + // MapBase stuff + // lvalue + mapref &operator=( const mapref &other ) + { + if( this != &other ) + { + the_item = other.the_item; + s.setItem( key, other.the_item ); + } + return *this; + } + + mapref &operator=( const T &ob ) + { + the_item = ob; + s.setItem( key, ob ); + return *this; + } + + // rvalue + operator T() const + { + return the_item; + } + + // forward everything else to the_item + PyObject *ptr() const + { + return the_item.ptr(); + } + + int reference_count() const + { // the mapref count + return the_item.reference_count(); + } + + Type type() const + { + return the_item.type(); + } + + String str() const + { + return the_item.str(); + } + + String repr() const + { + return the_item.repr(); + } + + bool hasAttr( const std::string &attr_name ) const + { + return the_item.hasAttr( attr_name ); + } + + Object getAttr( const std::string &attr_name ) const + { + return the_item.getAttr( attr_name ); + } + + Object getItem( const Object &k ) const + { + return the_item.getItem( k ); + } + + long hashValue() const + { + return the_item.hashValue(); + } + + bool isCallable() const + { + return the_item.isCallable(); + } + + bool isInstance() const + { + return the_item.isInstance(); + } + + bool isList() const + { + return the_item.isList(); + } + + bool isMapping() const + { + return the_item.isMapping(); + } + + bool isNumeric() const + { + return the_item.isNumeric(); + } + + bool isSequence() const + { + return the_item.isSequence(); + } + + bool isTrue() const + { + return the_item.isTrue(); + } + + bool isType( const Type &t ) const + { + return the_item.isType( t ); + } + + bool isTuple() const + { + return the_item.isTuple(); + } + + bool isString() const + { + return the_item.isString(); + } + + // Commands + void setAttr( const std::string &attr_name, const Object &value ) + { + the_item.setAttr( attr_name, value ); + } + + void delAttr( const std::string &attr_name ) + { + the_item.delAttr( attr_name ); + } + + void delItem( const Object &k ) + { + the_item.delItem( k ); + } + }; // end of mapref + +#if 0 + // TMM: now for mapref + template< class T > + bool operator==( const mapref &left, const mapref &right ) + { + return true; // NOT completed. + } + + template< class T > + bool operator!=( const mapref &left, const mapref &right ) + { + return true; // not completed. + } +#endif + + template + class MapBase: public Object + { + protected: + explicit MapBase() + {} + public: + // reference: proxy class for implementing [] + // TMM: 26Jun'01 - the types + // If you assume that Python mapping is a hash_map... + // hash_map::value_type is not assignable, but + //( *it ).second = data must be a valid expression + typedef size_t size_type; + typedef Object key_type; + typedef mapref data_type; + typedef std::pair< const T, T > value_type; + typedef std::pair< const T, mapref > reference; + typedef const std::pair< const T, const T > const_reference; + typedef std::pair< const T, mapref > pointer; + + // Constructor + explicit MapBase( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + // TMM: 02Jul'01 - changed MapBase to Object in next line + MapBase( const Object &ob ) + : Object( ob ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + MapBase &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + MapBase &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && PyMapping_Check( pyob ); + } + + // Clear -- PyMapping Clear is missing + // + + void clear() + { + List k = keys(); + for( List::iterator i = k.begin(); i != k.end(); i++ ) + { + delItem( *i ); + } + } + + virtual size_type size() const + { + return PyMapping_Length( ptr() ); + } + + // Element Access + T operator[]( const std::string &key ) const + { + return getItem( key ); + } + + T operator[]( const Object &key ) const + { + return getItem( key ); + } + + mapref operator[]( const char *key ) + { + return mapref( *this, key ); + } + + mapref operator[]( const std::string &key ) + { + return mapref( *this, key ); + } + + mapref operator[]( const Object &key ) + { + return mapref( *this, key ); + } + + int length() const + { + return PyMapping_Length( ptr() ); + } + + bool hasKey( const std::string &s ) const + { + return PyMapping_HasKeyString( ptr(),const_cast( s.c_str() ) ) != 0; + } + + bool hasKey( const Object &s ) const + { + return PyMapping_HasKey( ptr(), s.ptr() ) != 0; + } + + T getItem( const std::string &s ) const + { + return T( asObject( PyMapping_GetItemString( ptr(),const_cast( s.c_str() ) ) ) ); + } + + T getItem( const Object &s ) const + { + return T( asObject( PyObject_GetItem( ptr(), s.ptr() ) ) ); + } + + virtual void setItem( const char *s, const Object &ob ) + { + if( PyMapping_SetItemString( ptr(), const_cast( s ), *ob ) == -1 ) + { + throw Exception(); + } + } + + virtual void setItem( const std::string &s, const Object &ob ) + { + if( PyMapping_SetItemString( ptr(), const_cast( s.c_str() ), *ob ) == -1 ) + { + throw Exception(); + } + } + + virtual void setItem( const Object &s, const Object &ob ) + { + if( PyObject_SetItem( ptr(), s.ptr(), ob.ptr() ) == -1 ) + { + throw Exception(); + } + } + + void delItem( const std::string &s ) + { + if( PyMapping_DelItemString( ptr(), const_cast( s.c_str() ) ) == -1 ) + { + throw Exception(); + } + } + + void delItem( const Object &s ) + { + if( PyMapping_DelItem( ptr(), *s ) == -1 ) + { + throw Exception(); + } + } + + // Queries + List keys() const + { + return List( PyMapping_Keys( ptr() ), true ); + } + + List values() const + { + // each returned item is a (key, value) pair + return List( PyMapping_Values( ptr() ), true ); + } + + List items() const + { + return List( PyMapping_Items( ptr() ), true ); + } + + class iterator + { + // : public forward_iterator_parent( std::pair ) { + protected: + typedef std::forward_iterator_tag iterator_category; + typedef std::pair< const T, T > value_type; + typedef int difference_type; + typedef std::pair< const T, mapref > pointer; + typedef std::pair< const T, mapref > reference; + + friend class MapBase; + // + MapBase *map; + List keys; // for iterating over the map + int pos; // index into the keys + + public: + ~iterator() + {} + + iterator() + : map( 0 ) + , keys() + , pos( 0 ) + {} + + iterator( MapBase *m, bool end = false ) + : map( m ) + , keys( m->keys() ) + , pos( end ? keys.length() : 0 ) + {} + + iterator( const iterator &other ) + : map( other.map ) + , keys( other.keys ) + , pos( other.pos ) + {} + + iterator( MapBase *map_, List keys_, int pos_ ) + : map( map_ ) + , keys( keys_ ) + , pos( pos_ ) + {} + + reference operator*() + { + Object key = keys[ pos ]; + return std::make_pair( key, mapref( *map, key ) ); + } + + iterator &operator=( const iterator &other ) + { + if( this != &other ) + { + map = other.map; + keys = other.keys; + pos = other.pos; + } + return *this; + } + + bool eql( const iterator &other ) const + { + return map->ptr() == other.map->ptr() && pos == other.pos; + } + + bool neq( const iterator &other ) const + { + return map->ptr() != other.map->ptr() || pos != other.pos; + } + + // pointer operator->() { + // return ; + // } + + // prefix ++ + iterator &operator++() + { + pos++; + return *this; + } + + // postfix ++ + iterator operator++( int ) + { + return iterator( map, keys, pos++ ); + } + + // prefix -- + iterator &operator--() + { + pos--; + return *this; + } + + // postfix -- + iterator operator--( int ) + { + return iterator( map, keys, pos-- ); + } + + std::string diagnose() const + { + std::OSTRSTREAM oss; + oss << "iterator diagnosis " << map << ", " << pos << std::ends; + return std::string( oss.str() ); + } + }; // end of class MapBase::iterator + + iterator begin() + { + return iterator( this, false ); + } + + iterator end() + { + return iterator( this, true ); + } + + class const_iterator + { + protected: + typedef std::forward_iterator_tag iterator_category; + typedef const std::pair< const T, T > value_type; + typedef int difference_type; + typedef const std::pair< const T, T > pointer; + typedef const std::pair< const T, T > reference; + + friend class MapBase; + const MapBase *map; + List keys; // for iterating over the map + int pos; // index into the keys + + public: + ~const_iterator() + {} + + const_iterator() + : map( 0 ) + , keys() + , pos() + {} + + const_iterator( const MapBase *m, List k, int p ) + : map( m ) + , keys( k ) + , pos( p ) + {} + + const_iterator( const const_iterator &other ) + : map( other.map ) + , keys( other.keys ) + , pos( other.pos ) + {} + + bool eql( const const_iterator &other ) const + { + return map->ptr() == other.map->ptr() && pos == other.pos; + } + + bool neq( const const_iterator &other ) const + { + return map->ptr() != other.map->ptr() || pos != other.pos; + } + + + // const_reference operator*() { + // Object key = *pos; + // return std::make_pair( key, map->[key] ); + // GCC < 3 barfes on this line at the '['. + // } + + const_reference operator*() + { + Object key = keys[ pos ]; + return std::make_pair( key, mapref( *map, key ) ); + } + + const_iterator &operator=( const const_iterator &other ) + { + if( this != &other ) + { + map = other.map; + keys = other.keys; + pos = other.pos; + } + return *this; + } + + // prefix ++ + const_iterator &operator++() + { + pos++; + return *this; + } + + // postfix ++ + const_iterator operator++( int ) + { + return const_iterator( map, keys, pos++ ); + } + + // prefix -- + const_iterator &operator--() + { + pos--; + return *this; + } + + // postfix -- + const_iterator operator--( int ) + { + return const_iterator( map, keys, pos-- ); + } + }; // end of class MapBase::const_iterator + + const_iterator begin() const + { + return const_iterator( this, keys(), 0 ); + } + + const_iterator end() const + { + return const_iterator( this, keys(), length() ); + } + + }; // end of MapBase + + typedef MapBase Mapping; + + template bool operator==( const EXPLICIT_TYPENAME MapBase::iterator &left, const EXPLICIT_TYPENAME MapBase::iterator &right ); + template bool operator!=( const EXPLICIT_TYPENAME MapBase::iterator &left, const EXPLICIT_TYPENAME MapBase::iterator &right ); + template bool operator==( const EXPLICIT_TYPENAME MapBase::const_iterator &left, const EXPLICIT_TYPENAME MapBase::const_iterator &right ); + template bool operator!=( const EXPLICIT_TYPENAME MapBase::const_iterator &left, const EXPLICIT_TYPENAME MapBase::const_iterator &right ); + + extern bool operator==( const Mapping::iterator &left, const Mapping::iterator &right ); + extern bool operator!=( const Mapping::iterator &left, const Mapping::iterator &right ); + extern bool operator==( const Mapping::const_iterator &left, const Mapping::const_iterator &right ); + extern bool operator!=( const Mapping::const_iterator &left, const Mapping::const_iterator &right ); + + + // ================================================== + // class Dict + class Dict: public Mapping + { + public: + // Constructor + explicit Dict( PyObject *pyob, bool owned=false ) + : Mapping( pyob, owned ) + { + validate(); + } + + Dict( const Object &ob ) + : Mapping( ob ) + { + validate(); + } + + // Creation + Dict() + { + set( PyDict_New(), true ); + validate(); + } + + // Assignment acquires new ownership of pointer + Dict &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Dict &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && Py::_Dict_Check( pyob ); + } + }; + + class Callable: public Object + { + public: + // Constructor + explicit Callable() + : Object() + {} + + explicit Callable( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + Callable( const Object &ob ) + : Object( ob ) + { + validate(); + } + + // Assignment acquires new ownership of pointer + Callable &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Callable &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + // Membership + virtual bool accepts( PyObject *pyob ) const + { + return pyob && PyCallable_Check( pyob ); + } + + // Call + Object apply( const Tuple &args ) const + { + return asObject( PyObject_CallObject( ptr(), args.ptr() ) ); + } + + // Call with keywords + Object apply( const Tuple &args, const Dict &kw ) const + { + return asObject( PyEval_CallObjectWithKeywords( ptr(), args.ptr(), kw.ptr() ) ); + } + + Object apply( PyObject *pargs = 0 ) const + { + return apply( Tuple( pargs ) ); + } + }; + + class Module: public Object + { + public: + explicit Module( PyObject *pyob, bool owned = false ) + : Object( pyob, owned ) + { + validate(); + } + + // Construct from module name + explicit Module( const std::string &s ) + : Object() + { + PyObject *m = PyImport_AddModule( const_cast( s.c_str() ) ); + set( m, false ); + validate(); + } + + // Copy constructor acquires new ownership of pointer + Module( const Module &ob ) + : Object( *ob ) + { + validate(); + } + + Module &operator=( const Object &rhs ) + { + return *this = *rhs; + } + + Module &operator=( PyObject *rhsp ) + { + if( ptr() != rhsp ) + set( rhsp ); + return *this; + } + + Dict getDict() const + { + return Dict( PyModule_GetDict( ptr() ) ); + // Caution -- PyModule_GetDict returns borrowed reference! + } + }; + + // Call function helper + inline Object Object::callMemberFunction( const std::string &function_name ) const + { + Callable target( getAttr( function_name ) ); + Tuple args( 0 ); + return target.apply( args ); + } + + inline Object Object::callMemberFunction( const std::string &function_name, const Tuple &args ) const + { + Callable target( getAttr( function_name ) ); + return target.apply( args ); + } + + inline Object Object::callMemberFunction( const std::string &function_name, const Tuple &args, const Dict &kw ) const + { + Callable target( getAttr( function_name ) ); + return target.apply( args, kw ); + } + + // Numeric interface + inline Object operator+( const Object &a ) + { + return asObject( PyNumber_Positive( *a ) ); + } + + inline Object operator-( const Object &a ) + { + return asObject( PyNumber_Negative( *a ) ); + } + + inline Object abs( const Object &a ) + { + return asObject( PyNumber_Absolute( *a ) ); + } + + //------------------------------------------------------------ + // operator + + inline Object operator+( const Object &a, const Object &b ) + { + return asObject( PyNumber_Add( *a, *b ) ); + } + + inline Object operator+( const Object &a, int j ) + { + return asObject( PyNumber_Add( *a, *Long( j ) ) ); + } + + inline Object operator+( const Object &a, long j ) + { + return asObject( PyNumber_Add( *a, *Long( j ) ) ); + } + + inline Object operator+( const Object &a, double v ) + { + return asObject( PyNumber_Add( *a, *Float( v ) ) ); + } + + inline Object operator+( int j, const Object &b ) + { + return asObject( PyNumber_Add( *Long( j ), *b ) ); + } + + inline Object operator+( long j, const Object &b ) + { + return asObject( PyNumber_Add( *Long( j ), *b ) ); + } + + inline Object operator+( double v, const Object &b ) + { + return asObject( PyNumber_Add( *Float( v ), *b ) ); + } + + //------------------------------------------------------------ + // operator - + inline Object operator-( const Object &a, const Object &b ) + { + return asObject( PyNumber_Subtract( *a, *b ) ); + } + + inline Object operator-( const Object &a, int j ) + { + return asObject( PyNumber_Subtract( *a, *Long( j ) ) ); + } + + inline Object operator-( const Object &a, double v ) + { + return asObject( PyNumber_Subtract( *a, *Float( v ) ) ); + } + + inline Object operator-( int j, const Object &b ) + { + return asObject( PyNumber_Subtract( *Long( j ), *b ) ); + } + + inline Object operator-( double v, const Object &b ) + { + return asObject( PyNumber_Subtract( *Float( v ), *b ) ); + } + + //------------------------------------------------------------ + // operator * + inline Object operator*( const Object &a, const Object &b ) + { + return asObject( PyNumber_Multiply( *a, *b ) ); + } + + inline Object operator*( const Object &a, int j ) + { + return asObject( PyNumber_Multiply( *a, *Long( j ) ) ); + } + + inline Object operator*( const Object &a, double v ) + { + return asObject( PyNumber_Multiply( *a, *Float( v ) ) ); + } + + inline Object operator*( int j, const Object &b ) + { + return asObject( PyNumber_Multiply( *Long( j ), *b ) ); + } + + inline Object operator*( double v, const Object &b ) + { + return asObject( PyNumber_Multiply( *Float( v ), *b ) ); + } + + //------------------------------------------------------------ + // operator / + inline Object operator/( const Object &a, const Object &b ) + { + return asObject( PyNumber_TrueDivide( *a, *b ) ); + } + + inline Object operator/( const Object &a, int j ) + { + return asObject( PyNumber_TrueDivide( *a, *Long( j ) ) ); + } + + inline Object operator/( const Object &a, double v ) + { + return asObject( PyNumber_TrueDivide( *a, *Float( v ) ) ); + } + + inline Object operator/( int j, const Object &b ) + { + return asObject( PyNumber_TrueDivide( *Long( j ), *b ) ); + } + + inline Object operator/( double v, const Object &b ) + { + return asObject( PyNumber_TrueDivide( *Float( v ), *b ) ); + } + + //------------------------------------------------------------ + // operator % + inline Object operator%( const Object &a, const Object &b ) + { + return asObject( PyNumber_Remainder( *a, *b ) ); + } + + inline Object operator%( const Object &a, int j ) + { + return asObject( PyNumber_Remainder( *a, *Long( j ) ) ); + } + + inline Object operator%( const Object &a, double v ) + { + return asObject( PyNumber_Remainder( *a, *Float( v ) ) ); + } + + inline Object operator%( int j, const Object &b ) + { + return asObject( PyNumber_Remainder( *Long( j ), *b ) ); + } + + inline Object operator%( double v, const Object &b ) + { + return asObject( PyNumber_Remainder( *Float( v ), *b ) ); + } + + //------------------------------------------------------------ + // type + inline Object type( const Exception &) // return the type of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch( &ptype, &pvalue, &ptrace ); + Object result; + if( ptype ) + result = ptype; + PyErr_Restore( ptype, pvalue, ptrace ); + return result; + } + + inline Object value( const Exception &) // return the value of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch( &ptype, &pvalue, &ptrace ); + Object result; + if( pvalue ) + result = pvalue; + PyErr_Restore( ptype, pvalue, ptrace ); + return result; + } + + inline Object trace( const Exception &) // return the traceback of the error + { + PyObject *ptype, *pvalue, *ptrace; + PyErr_Fetch( &ptype, &pvalue, &ptrace ); + Object result; + if( ptrace ) + result = ptrace; + PyErr_Restore( ptype, pvalue, ptrace ); + return result; + } + + template + String seqref::str() const + { + return the_item.str(); + } + + template + String seqref::repr() const + { + return the_item.repr(); + } + +} // namespace Py +#endif // __CXX_Objects__h diff --git a/src/CXX/Python3/PythonType.hxx b/src/CXX/Python3/PythonType.hxx new file mode 100644 index 000000000..bb77bb16e --- /dev/null +++ b/src/CXX/Python3/PythonType.hxx @@ -0,0 +1,114 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#ifndef __CXX_PythonType__h +#define __CXX_PythonType__h + +namespace Py +{ + class PythonType + { + public: + // if you define one sequence method you must define + // all of them except the assigns + + PythonType( size_t base_size, int itemsize, const char *default_name ); + virtual ~PythonType(); + + const char *getName() const; + const char *getDoc() const; + + PyTypeObject *type_object() const; + PythonType &name( const char *nam ); + PythonType &doc( const char *d ); + + PythonType &supportClass( void ); +#ifdef PYCXX_PYTHON_2TO3 + PythonType &supportPrint( void ); +#endif + PythonType &supportGetattr( void ); + PythonType &supportSetattr( void ); + PythonType &supportGetattro( void ); + PythonType &supportSetattro( void ); +#ifdef PYCXX_PYTHON_2TO3 + PythonType &supportCompare( void ); +#endif + PythonType &supportRichCompare( void ); + PythonType &supportRepr( void ); + PythonType &supportStr( void ); + PythonType &supportHash( void ); + PythonType &supportCall( void ); + PythonType &supportIter( void ); + + PythonType &supportSequenceType( void ); + PythonType &supportMappingType( void ); + PythonType &supportNumberType( void ); + PythonType &supportBufferType( void ); + + PythonType &set_tp_dealloc( void (*tp_dealloc)( PyObject * ) ); + PythonType &set_tp_init( int (*tp_init)( PyObject *self, PyObject *args, PyObject *kwds ) ); + PythonType &set_tp_new( PyObject *(*tp_new)( PyTypeObject *subtype, PyObject *args, PyObject *kwds ) ); + PythonType &set_methods( PyMethodDef *methods ); + + // call once all support functions have been called to ready the type + bool readyType(); + + protected: + void init_sequence(); + void init_mapping(); + void init_number(); + void init_buffer(); + + PyTypeObject *table; + PySequenceMethods *sequence_table; + PyMappingMethods *mapping_table; + PyNumberMethods *number_table; + PyBufferProcs *buffer_table; + + private: + // + // prevent the compiler generating these unwanted functions + // + PythonType( const PythonType &tb ); // unimplemented + void operator=( const PythonType &t ); // unimplemented + + }; + +} // Namespace Py + +// End of __CXX_PythonType__h +#endif diff --git a/src/CXX/Python3/cxx_extensions.cxx b/src/CXX/Python3/cxx_extensions.cxx new file mode 100644 index 000000000..e049e16b9 --- /dev/null +++ b/src/CXX/Python3/cxx_extensions.cxx @@ -0,0 +1,1977 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- +#include "CXX/Extensions.hxx" +#include "CXX/Exception.hxx" + +#include + +#ifdef PYCXX_DEBUG +// +// Functions useful when debugging PyCXX +// +void bpt( void ) +{ +} + +void printRefCount( PyObject *obj ) +{ + std::cout << "RefCount of 0x" << std::hex << reinterpret_cast< unsigned int >( obj ) << std::dec << " is " << Py_REFCNT( obj ) << std::endl; +} +#endif + +namespace Py +{ + +void Object::validate() +{ + // release pointer if not the right type + if( !accepts( p ) ) + { +#if defined( _CPPRTTI ) || defined( __GNUG__ ) + std::string s( "PyCXX: Error creating object of type " ); + s += (typeid( *this )).name(); + + if( p != NULL ) + { + String from_repr = repr(); + s += " from "; + s += from_repr.as_std_string(); + } + else + { + s += " from (nil)"; + } +#endif + release(); + if( PyErr_Occurred() ) + { // Error message already set + throw Exception(); + } + // Better error message if RTTI available +#if defined( _CPPRTTI ) || defined( __GNUG__ ) + throw TypeError( s ); +#else + throw TypeError( "PyCXX: type error." ); +#endif + } +} + +//================================================================================ +// +// Implementation of MethodTable +// +//================================================================================ + +PyMethodDef MethodTable::method( const char *method_name, PyCFunction f, int flags, const char *doc ) +{ + PyMethodDef m; + m.ml_name = const_cast( method_name ); + m.ml_meth = f; + m.ml_flags = flags; + m.ml_doc = const_cast( doc ); + return m; +} + +MethodTable::MethodTable() +{ + t.push_back( method( 0, 0, 0, 0 ) ); + mt = NULL; +} + +MethodTable::~MethodTable() +{ + delete [] mt; +} + +void MethodTable::add( const char *method_name, PyCFunction f, const char *doc, int flag ) +{ + if( !mt ) + { + t.insert( t.end()-1, method( method_name, f, flag, doc ) ); + } + else + { + throw RuntimeError( "Too late to add a module method!" ); + } +} + +PyMethodDef *MethodTable::table() +{ + if( !mt ) + { + Py_ssize_t t1size = t.size(); + mt = new PyMethodDef[ t1size ]; + int j = 0; + for( std::vector::iterator i = t.begin(); i != t.end(); i++ ) + { + mt[ j++ ] = *i; + } + } + return mt; +} + +//================================================================================ +// +// Implementation of ExtensionModule +// +//================================================================================ +ExtensionModuleBase::ExtensionModuleBase( const char *name ) +: m_module_name( name ) +, m_full_module_name( __Py_PackageContext() != NULL ? std::string( __Py_PackageContext() ) : m_module_name ) +, m_method_table() +//m_module_def +, m_module( NULL ) +{} + +ExtensionModuleBase::~ExtensionModuleBase() +{} + +const std::string &ExtensionModuleBase::name() const +{ + return m_module_name; +} + +const std::string &ExtensionModuleBase::fullName() const +{ + return m_full_module_name; +} + +class ExtensionModuleBasePtr : public PythonExtension +{ +public: + ExtensionModuleBasePtr( ExtensionModuleBase *_module ) + : module( _module ) + {} + + virtual ~ExtensionModuleBasePtr() + {} + + ExtensionModuleBase *module; +}; + +void ExtensionModuleBase::initialize( const char *module_doc ) +{ + memset( &m_module_def, 0, sizeof( m_module_def ) ); + + m_module_def.m_name = const_cast( m_module_name.c_str() ); + m_module_def.m_doc = const_cast( module_doc ); + m_module_def.m_methods = m_method_table.table(); + // where does module_ptr get passed in? + + m_module = PyModule_Create( &m_module_def ); +} + +Py::Module ExtensionModuleBase::module( void ) const +{ + return Module( m_module ); +} + +Py::Dict ExtensionModuleBase::moduleDictionary( void ) const +{ + return module().getDict(); +} + +//================================================================================ +// +// Implementation of PythonType +// +//================================================================================ +extern "C" +{ + static void standard_dealloc( PyObject *p ); + // + // All the following functions redirect the call from Python + // onto the matching virtual function in PythonExtensionBase + // + static int print_handler( PyObject *, FILE *, int ); + static PyObject *getattr_handler( PyObject *, char * ); + static int setattr_handler( PyObject *, char *, PyObject * ); + static PyObject *getattro_handler( PyObject *, PyObject * ); + static int setattro_handler( PyObject *, PyObject *, PyObject * ); + static PyObject *rich_compare_handler( PyObject *, PyObject *, int ); + static PyObject *repr_handler( PyObject * ); + static PyObject *str_handler( PyObject * ); + static Py_hash_t hash_handler( PyObject * ); + static PyObject *call_handler( PyObject *, PyObject *, PyObject * ); + static PyObject *iter_handler( PyObject * ); + static PyObject *iternext_handler( PyObject * ); + + // Sequence methods + static Py_ssize_t sequence_length_handler( PyObject * ); + static PyObject *sequence_concat_handler( PyObject *,PyObject * ); + static PyObject *sequence_repeat_handler( PyObject *, Py_ssize_t ); + static PyObject *sequence_item_handler( PyObject *, Py_ssize_t ); + static int sequence_ass_item_handler( PyObject *, Py_ssize_t, PyObject * ); + + // Mapping + static Py_ssize_t mapping_length_handler( PyObject * ); + static PyObject *mapping_subscript_handler( PyObject *, PyObject * ); + static int mapping_ass_subscript_handler( PyObject *, PyObject *, PyObject * ); + + // Numeric methods + static PyObject *number_negative_handler( PyObject * ); + static PyObject *number_positive_handler( PyObject * ); + static PyObject *number_absolute_handler( PyObject * ); + static PyObject *number_invert_handler( PyObject * ); + static PyObject *number_int_handler( PyObject * ); + static PyObject *number_float_handler( PyObject * ); + static PyObject *number_add_handler( PyObject *, PyObject * ); + static PyObject *number_subtract_handler( PyObject *, PyObject * ); + static PyObject *number_multiply_handler( PyObject *, PyObject * ); + static PyObject *number_remainder_handler( PyObject *, PyObject * ); + static PyObject *number_divmod_handler( PyObject *, PyObject * ); + static PyObject *number_lshift_handler( PyObject *, PyObject * ); + static PyObject *number_rshift_handler( PyObject *, PyObject * ); + static PyObject *number_and_handler( PyObject *, PyObject * ); + static PyObject *number_xor_handler( PyObject *, PyObject * ); + static PyObject *number_or_handler( PyObject *, PyObject * ); + static PyObject *number_power_handler( PyObject *, PyObject *, PyObject * ); + + // Buffer + static int buffer_get_handler( PyObject *, Py_buffer *, int ); + static void buffer_release_handler( PyObject *, Py_buffer * ); +} + +extern "C" void standard_dealloc( PyObject *p ) +{ + PyMem_DEL( p ); +} + +bool PythonType::readyType() +{ + return PyType_Ready( table ) >= 0; +} + +PythonType &PythonType::supportSequenceType() +{ + if( !sequence_table ) + { + sequence_table = new PySequenceMethods; + memset( sequence_table, 0, sizeof( PySequenceMethods ) ); // ensure new fields are 0 + table->tp_as_sequence = sequence_table; + sequence_table->sq_length = sequence_length_handler; + sequence_table->sq_concat = sequence_concat_handler; + sequence_table->sq_repeat = sequence_repeat_handler; + sequence_table->sq_item = sequence_item_handler; + + sequence_table->sq_ass_item = sequence_ass_item_handler; // BAS setup seperately? + // QQQ sq_inplace_concat + // QQQ sq_inplace_repeat + } + return *this; +} + +PythonType &PythonType::supportMappingType() +{ + if( !mapping_table ) + { + mapping_table = new PyMappingMethods; + memset( mapping_table, 0, sizeof( PyMappingMethods ) ); // ensure new fields are 0 + table->tp_as_mapping = mapping_table; + mapping_table->mp_length = mapping_length_handler; + mapping_table->mp_subscript = mapping_subscript_handler; + mapping_table->mp_ass_subscript = mapping_ass_subscript_handler; // BAS setup seperately? + } + return *this; +} + +PythonType &PythonType::supportNumberType() +{ + if( !number_table ) + { + number_table = new PyNumberMethods; + memset( number_table, 0, sizeof( PyNumberMethods ) ); // ensure new fields are 0 + table->tp_as_number = number_table; + number_table->nb_add = number_add_handler; + number_table->nb_subtract = number_subtract_handler; + number_table->nb_multiply = number_multiply_handler; + number_table->nb_remainder = number_remainder_handler; + number_table->nb_divmod = number_divmod_handler; + number_table->nb_power = number_power_handler; + number_table->nb_negative = number_negative_handler; + number_table->nb_positive = number_positive_handler; + number_table->nb_absolute = number_absolute_handler; + number_table->nb_invert = number_invert_handler; + number_table->nb_lshift = number_lshift_handler; + number_table->nb_rshift = number_rshift_handler; + number_table->nb_and = number_and_handler; + number_table->nb_xor = number_xor_handler; + number_table->nb_or = number_or_handler; + number_table->nb_int = number_int_handler; + number_table->nb_float = number_float_handler; + + // QQQ lots of new methods to add + } + return *this; +} + +PythonType &PythonType::supportBufferType() +{ + if( !buffer_table ) + { + buffer_table = new PyBufferProcs; + memset( buffer_table, 0, sizeof( PyBufferProcs ) ); // ensure new fields are 0 + table->tp_as_buffer = buffer_table; + buffer_table->bf_getbuffer = buffer_get_handler; + buffer_table->bf_releasebuffer = buffer_release_handler; + } + return *this; +} + +// if you define one sequence method you must define +// all of them except the assigns + +PythonType::PythonType( size_t basic_size, int itemsize, const char *default_name ) +: table( new PyTypeObject ) +, sequence_table( NULL ) +, mapping_table( NULL ) +, number_table( NULL ) +, buffer_table( NULL ) +{ + // PyTypeObject is defined in /Include/object.h + + memset( table, 0, sizeof( PyTypeObject ) ); // ensure new fields are 0 + *reinterpret_cast( table ) = py_object_initializer; + reinterpret_cast( table )->ob_type = _Type_Type(); + // QQQ table->ob_size = 0; + table->tp_name = const_cast( default_name ); + table->tp_basicsize = basic_size; + table->tp_itemsize = itemsize; + + // Methods to implement standard operations + table->tp_dealloc = (destructor)standard_dealloc; + table->tp_print = 0; + table->tp_getattr = 0; + table->tp_setattr = 0; + table->tp_repr = 0; + + // Method suites for standard classes + table->tp_as_number = 0; + table->tp_as_sequence = 0; + table->tp_as_mapping = 0; + + // More standard operations (here for binary compatibility) + table->tp_hash = 0; + table->tp_call = 0; + table->tp_str = 0; + table->tp_getattro = 0; + table->tp_setattro = 0; + + // Functions to access object as input/output buffer + table->tp_as_buffer = 0; + + // Flags to define presence of optional/expanded features + table->tp_flags = Py_TPFLAGS_DEFAULT; + + // Documentation string + table->tp_doc = 0; + + table->tp_traverse = 0; + + // delete references to contained objects + table->tp_clear = 0; + + // Assigned meaning in release 2.1 + // rich comparisons + table->tp_richcompare = 0; + // weak reference enabler + table->tp_weaklistoffset = 0; + + // Iterators + table->tp_iter = 0; + table->tp_iternext = 0; + + // Attribute descriptor and subclassing stuff + table->tp_methods = 0; + table->tp_members = 0; + table->tp_getset = 0; + table->tp_base = 0; + table->tp_dict = 0; + table->tp_descr_get = 0; + table->tp_descr_set = 0; + table->tp_dictoffset = 0; + table->tp_init = 0; + table->tp_alloc = 0; + table->tp_new = 0; + table->tp_free = 0; // Low-level free-memory routine + table->tp_is_gc = 0; // For PyObject_IS_GC + table->tp_bases = 0; + table->tp_mro = 0; // method resolution order + table->tp_cache = 0; + table->tp_subclasses = 0; + table->tp_weaklist = 0; + table->tp_del = 0; + + // Type attribute cache version tag. Added in version 2.6 + table->tp_version_tag = 0; + +#ifdef COUNT_ALLOCS + table->tp_alloc = 0; + table->tp_free = 0; + table->tp_maxalloc = 0; + table->tp_orev = 0; + table->tp_next = 0; +#endif +} + +PythonType::~PythonType() +{ + delete table; + delete sequence_table; + delete mapping_table; + delete number_table; + delete buffer_table; +} + +PyTypeObject *PythonType::type_object() const +{ + return table; +} + +PythonType &PythonType::name( const char *nam ) +{ + table->tp_name = const_cast( nam ); + return *this; +} + +const char *PythonType::getName() const +{ + return table->tp_name; +} + +PythonType &PythonType::doc( const char *d ) +{ + table->tp_doc = const_cast( d ); + return *this; +} + +const char *PythonType::getDoc() const +{ + return table->tp_doc; +} + +PythonType &PythonType::set_tp_dealloc( void (*tp_dealloc)( PyObject *self ) ) +{ + table->tp_dealloc = tp_dealloc; + return *this; +} + +PythonType &PythonType::set_tp_init( int (*tp_init)( PyObject *self, PyObject *args, PyObject *kwds ) ) +{ + table->tp_init = tp_init; + return *this; +} + +PythonType &PythonType::set_tp_new( PyObject *(*tp_new)( PyTypeObject *subtype, PyObject *args, PyObject *kwds ) ) +{ + table->tp_new = tp_new; + return *this; +} + +PythonType &PythonType::set_methods( PyMethodDef *methods ) +{ + table->tp_methods = methods; + return *this; +} + +PythonType &PythonType::supportClass() +{ + table->tp_flags |= Py_TPFLAGS_BASETYPE; + return *this; +} + +#ifdef PYCXX_PYTHON_2TO3 +PythonType &PythonType::supportPrint() +{ + table->tp_print = print_handler; + return *this; +} +#endif + +PythonType &PythonType::supportGetattr() +{ + table->tp_getattr = getattr_handler; + return *this; +} + +PythonType &PythonType::supportSetattr() +{ + table->tp_setattr = setattr_handler; + return *this; +} + +PythonType &PythonType::supportGetattro() +{ + table->tp_getattro = getattro_handler; + return *this; +} + +PythonType &PythonType::supportSetattro() +{ + table->tp_setattro = setattro_handler; + return *this; +} + +#ifdef PYCXX_PYTHON_2TO3 +PythonType &PythonType::supportCompare( void ) +{ + return *this; +} +#endif + + +PythonType &PythonType::supportRichCompare() +{ + table->tp_richcompare = rich_compare_handler; + return *this; +} + +PythonType &PythonType::supportRepr() +{ + table->tp_repr = repr_handler; + return *this; +} + +PythonType &PythonType::supportStr() +{ + table->tp_str = str_handler; + return *this; +} + +PythonType &PythonType::supportHash() +{ + table->tp_hash = hash_handler; + return *this; +} + +PythonType &PythonType::supportCall() +{ + table->tp_call = call_handler; + return *this; +} + +PythonType &PythonType::supportIter() +{ + table->tp_iter = iter_handler; + table->tp_iternext = iternext_handler; + return *this; +} + +//-------------------------------------------------------------------------------- +// +// Handlers +// +//-------------------------------------------------------------------------------- +PythonExtensionBase *getPythonExtensionBase( PyObject *self ) +{ + if( self->ob_type->tp_flags&Py_TPFLAGS_BASETYPE ) + { + PythonClassInstance *instance = reinterpret_cast( self ); + return instance->m_pycxx_object; + } + else + { + return static_cast( self ); + } +} + +#ifdef PYCXX_PYTHON_2TO3 +extern "C" int print_handler( PyObject *self, FILE *fp, int flags ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->print( fp, flags ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} +#endif + +extern "C" PyObject *getattr_handler( PyObject *self, char *name ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->getattr( name ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int setattr_handler( PyObject *self, char *name, PyObject *value ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->setattr( name, Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject *getattro_handler( PyObject *self, PyObject *name ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->getattro( Py::String( name ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int setattro_handler( PyObject *self, PyObject *name, PyObject *value ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->setattro( Py::String( name ), Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject *rich_compare_handler( PyObject *self, PyObject *other, int op ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->rich_compare( Py::Object( other ), op ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *repr_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->repr() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *str_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->str() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" Py_hash_t hash_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->hash(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject *call_handler( PyObject *self, PyObject *args, PyObject *kw ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + if( kw != NULL ) + return new_reference_to( p->call( Py::Object( args ), Py::Object( kw ) ) ); + else + return new_reference_to( p->call( Py::Object( args ), Py::Object() ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *iter_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->iter() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *iternext_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->iternext(); // might be a NULL ptr on end of iteration + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + + +// Sequence methods +extern "C" Py_ssize_t sequence_length_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->sequence_length(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject *sequence_concat_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->sequence_concat( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *sequence_repeat_handler( PyObject *self, Py_ssize_t count ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->sequence_repeat( count ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *sequence_item_handler( PyObject *self, Py_ssize_t index ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->sequence_item( index ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int sequence_ass_item_handler( PyObject *self, Py_ssize_t index, PyObject *value ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->sequence_ass_item( index, Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +// Mapping +extern "C" Py_ssize_t mapping_length_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->mapping_length(); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" PyObject *mapping_subscript_handler( PyObject *self, PyObject *key ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->mapping_subscript( Py::Object( key ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" int mapping_ass_subscript_handler( PyObject *self, PyObject *key, PyObject *value ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->mapping_ass_subscript( Py::Object( key ), Py::Object( value ) ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +// Number +extern "C" PyObject *number_negative_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_negative() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_positive_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_positive() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_absolute_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_absolute() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_invert_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_invert() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_int_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_int() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_float_handler( PyObject *self ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_float() ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_add_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_add( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_subtract_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_subtract( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_multiply_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_multiply( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_remainder_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_remainder( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_divmod_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_divmod( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_lshift_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_lshift( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_rshift_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_rshift( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_and_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_and( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_xor_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_xor( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_or_handler( PyObject *self, PyObject *other ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_or( Py::Object( other ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +extern "C" PyObject *number_power_handler( PyObject *self, PyObject *x1, PyObject *x2 ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return new_reference_to( p->number_power( Py::Object( x1 ), Py::Object( x2 ) ) ); + } + catch( Py::Exception & ) + { + return NULL; // indicate error + } +} + +// Buffer +extern "C" int buffer_get_handler( PyObject *self, Py_buffer *buf, int flags ) +{ + try + { + PythonExtensionBase *p = getPythonExtensionBase( self ); + return p->buffer_get( buf, flags ); + } + catch( Py::Exception & ) + { + return -1; // indicate error + } +} + +extern "C" void buffer_release_handler( PyObject *self, Py_buffer *buf ) +{ + PythonExtensionBase *p = getPythonExtensionBase( self ); + p->buffer_release( buf ); + // NOTE: No way to indicate error to Python +} + +//================================================================================ +// +// Implementation of PythonExtensionBase +// +//================================================================================ +#define missing_method( method ) \ + throw RuntimeError( "Extension object missing implement of " #method ); + +PythonExtensionBase::PythonExtensionBase() +{ + ob_refcnt = 0; +} + +PythonExtensionBase::~PythonExtensionBase() +{ + assert( ob_refcnt == 0 ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name ) +{ + Py::TupleN args; + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1 ) +{ + Py::TupleN args( arg1 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2 ) +{ + Py::TupleN args( arg1, arg2 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3 ) +{ + Py::TupleN args( arg1, arg2, arg3 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4, const Py::Object &arg5 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4, arg5 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6, + const Py::Object &arg7 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6, + const Py::Object &arg7, const Py::Object &arg8 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8 ); + return self().callMemberFunction( fn_name, args ); +} + +Py::Object PythonExtensionBase::callOnSelf( const std::string &fn_name, + const Py::Object &arg1, const Py::Object &arg2, const Py::Object &arg3, + const Py::Object &arg4, const Py::Object &arg5, const Py::Object &arg6, + const Py::Object &arg7, const Py::Object &arg8, const Py::Object &arg9 ) +{ + Py::TupleN args( arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 ); + return self().callMemberFunction( fn_name, args ); +} + +void PythonExtensionBase::reinit( Tuple &args, Dict &kwds ) +{ + throw RuntimeError( "Must not call __init__ twice on this class" ); +} + + +Py::Object PythonExtensionBase::genericGetAttro( const Py::String &name ) +{ + return asObject( PyObject_GenericGetAttr( selfPtr(), name.ptr() ) ); +} + +int PythonExtensionBase::genericSetAttro( const Py::String &name, const Py::Object &value ) +{ + return PyObject_GenericSetAttr( selfPtr(), name.ptr(), value.ptr() ); +} + +#ifdef PYCXX_PYTHON_2TO3 +int PythonExtensionBase::print( FILE *, int ) +{ + missing_method( print ); + return -1; +} +#endif + +Py::Object PythonExtensionBase::getattr( const char * ) +{ + missing_method( getattr ); + return Py::None(); +} + +int PythonExtensionBase::setattr( const char *, const Py::Object & ) +{ + missing_method( setattr ); + return -1; +} + +Py::Object PythonExtensionBase::getattro( const Py::String &name ) +{ + return asObject( PyObject_GenericGetAttr( selfPtr(), name.ptr() ) ); +} + +int PythonExtensionBase::setattro( const Py::String &name, const Py::Object &value ) +{ + return PyObject_GenericSetAttr( selfPtr(), name.ptr(), value.ptr() ); +} + + +int PythonExtensionBase::compare( const Py::Object & ) +{ + missing_method( compare ); + return -1; +} + +Py::Object PythonExtensionBase::rich_compare( const Py::Object &, int ) +{ + missing_method( rich_compare ); + return Py::None(); +} + +Py::Object PythonExtensionBase::repr() +{ + missing_method( repr ); + return Py::None(); +} + +Py::Object PythonExtensionBase::str() +{ + missing_method( str ); + return Py::None(); +} + +long PythonExtensionBase::hash() +{ + missing_method( hash ); + return -1; } + + +Py::Object PythonExtensionBase::call( const Py::Object &, const Py::Object & ) +{ + missing_method( call ); + return Py::None(); +} + +Py::Object PythonExtensionBase::iter() +{ + missing_method( iter ); + return Py::None(); +} + +PyObject *PythonExtensionBase::iternext() +{ + missing_method( iternext ); + return NULL; } + + + +// Sequence methods +int PythonExtensionBase::sequence_length() +{ + missing_method( sequence_length ); + return -1; } + + +Py::Object PythonExtensionBase::sequence_concat( const Py::Object & ) +{ + missing_method( sequence_concat ); + return Py::None(); +} + +Py::Object PythonExtensionBase::sequence_repeat( Py_ssize_t ) +{ + missing_method( sequence_repeat ); + return Py::None(); +} + +Py::Object PythonExtensionBase::sequence_item( Py_ssize_t ) +{ + missing_method( sequence_item ); + return Py::None(); +} + +int PythonExtensionBase::sequence_ass_item( Py_ssize_t, const Py::Object & ) +{ + missing_method( sequence_ass_item ); + return -1; +} + + +// Mapping +int PythonExtensionBase::mapping_length() +{ + missing_method( mapping_length ); + return -1; +} + + +Py::Object PythonExtensionBase::mapping_subscript( const Py::Object & ) +{ + missing_method( mapping_subscript ); + return Py::None(); +} + +int PythonExtensionBase::mapping_ass_subscript( const Py::Object &, const Py::Object & ) +{ + missing_method( mapping_ass_subscript ); + return -1; +} + +Py::Object PythonExtensionBase::number_negative() +{ + missing_method( number_negative ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_positive() +{ + missing_method( number_positive ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_absolute() +{ + missing_method( number_absolute ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_invert() +{ + missing_method( number_invert ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_int() +{ + missing_method( number_int ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_float() +{ + missing_method( number_float ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_long() +{ + missing_method( number_long ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_add( const Py::Object & ) +{ + missing_method( number_add ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_subtract( const Py::Object & ) +{ + missing_method( number_subtract ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_multiply( const Py::Object & ) +{ + missing_method( number_multiply ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_remainder( const Py::Object & ) +{ + missing_method( number_remainder ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_divmod( const Py::Object & ) +{ + missing_method( number_divmod ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_lshift( const Py::Object & ) +{ + missing_method( number_lshift ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_rshift( const Py::Object & ) +{ + missing_method( number_rshift ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_and( const Py::Object & ) +{ + missing_method( number_and ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_xor( const Py::Object & ) +{ + missing_method( number_xor ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_or( const Py::Object & ) +{ + missing_method( number_or ); + return Py::None(); +} + +Py::Object PythonExtensionBase::number_power( const Py::Object &, const Py::Object & ) +{ + missing_method( number_power ); + return Py::None(); +} + + +// Buffer +int PythonExtensionBase::buffer_get( Py_buffer *buf, int flags ) +{ + missing_method( buffer_get ); + return -1; +} + +int PythonExtensionBase::buffer_release( Py_buffer *buf ) +{ + /* This method is optional and only required if the buffer's + memory is dynamic. */ + return 0; +} + +//-------------------------------------------------------------------------------- +// +// Method call handlers for +// PythonExtensionBase +// ExtensionModuleBase +// +//-------------------------------------------------------------------------------- +// Note: Python calls noargs as varargs buts args==NULL +extern "C" PyObject *method_noargs_call_handler( PyObject *_self_and_name_tuple, PyObject * ) +{ + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + void *self_as_void = PyCapsule_GetPointer( self_in_cobject, NULL ); + if( self_as_void == NULL ) + return NULL; + + ExtensionModuleBase *self = static_cast( self_as_void ); + + Object result( self->invoke_method_noargs( PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ) ) ); + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } +} + +extern "C" PyObject *method_varargs_call_handler( PyObject *_self_and_name_tuple, PyObject *_args ) +{ + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + void *self_as_void = PyCapsule_GetPointer( self_in_cobject, NULL ); + if( self_as_void == NULL ) + return NULL; + + ExtensionModuleBase *self = static_cast( self_as_void ); + Tuple args( _args ); + Object result + ( + self->invoke_method_varargs + ( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ), + args + ) + ); + + return new_reference_to( result.ptr() ); + } + catch( Exception & ) + { + return 0; + } +} + +extern "C" PyObject *method_keyword_call_handler( PyObject *_self_and_name_tuple, PyObject *_args, PyObject *_keywords ) +{ + try + { + Tuple self_and_name_tuple( _self_and_name_tuple ); + + PyObject *self_in_cobject = self_and_name_tuple[0].ptr(); + void *self_as_void = PyCapsule_GetPointer( self_in_cobject, NULL ); + if( self_as_void == NULL ) + return NULL; + + ExtensionModuleBase *self = static_cast( self_as_void ); + + Tuple args( _args ); + + if( _keywords == NULL ) + { + Dict keywords; // pass an empty dict + + Object result + ( + self->invoke_method_keyword + ( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ), + args, + keywords + ) + ); + + return new_reference_to( result.ptr() ); + } + else + { + Dict keywords( _keywords ); // make dict + + Object result + ( + self->invoke_method_keyword + ( + PyCapsule_GetPointer( self_and_name_tuple[1].ptr(), NULL ), + args, + keywords + ) + ); + + return new_reference_to( result.ptr() ); + } + } + catch( Exception & ) + { + return 0; + } +} + + +//-------------------------------------------------------------------------------- +// +// ExtensionExceptionType +// +//-------------------------------------------------------------------------------- +ExtensionExceptionType::ExtensionExceptionType() + : Py::Object() +{ +} + +void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name ) +{ + std::string module_name( module.fullName() ); + module_name += "."; + module_name += name; + + set( PyErr_NewException( const_cast( module_name.c_str() ), NULL, NULL ), true ); +} + +void ExtensionExceptionType::init( ExtensionModuleBase &module, const std::string& name, ExtensionExceptionType &parent ) + { + std::string module_name( module.fullName() ); + module_name += "."; + module_name += name; + + set( PyErr_NewException( const_cast( module_name.c_str() ), parent.ptr(), NULL ), true ); +} + +ExtensionExceptionType::~ExtensionExceptionType() +{ +} + +Exception::Exception( ExtensionExceptionType &exception, const std::string& reason ) +{ + PyErr_SetString( exception.ptr(), reason.c_str() ); +} + +Exception::Exception( ExtensionExceptionType &exception, Object &reason ) +{ + PyErr_SetObject( exception.ptr(), reason.ptr() ); +} + +Exception::Exception( PyObject *exception, Object &reason ) +{ + PyErr_SetObject( exception, reason.ptr() ); +} + +#if 1 +//------------------------------------------------------------ +// compare operators +bool operator!=( const Long &a, const Long &b ) +{ + return a.as_long() != b.as_long(); +} + +bool operator!=( const Long &a, int b ) +{ + return a.as_long() != b; +} + +bool operator!=( const Long &a, long b ) +{ + return a.as_long() != b; +} + +bool operator!=( int a, const Long &b ) +{ + return a != b.as_long(); +} + +bool operator!=( long a, const Long &b ) +{ + return a != b.as_long(); +} + +//------------------------------ +bool operator==( const Long &a, const Long &b ) +{ + return a.as_long() == b.as_long(); +} + +bool operator==( const Long &a, int b ) +{ + return a.as_long() == b; +} + +bool operator==( const Long &a, long b ) +{ + return a.as_long() == b; +} + +bool operator==( int a, const Long &b ) +{ + return a == b.as_long(); +} + +bool operator==( long a, const Long &b ) +{ + return a == b.as_long(); +} + +//------------------------------ +bool operator>( const Long &a, const Long &b ) +{ + return a.as_long() > b.as_long(); +} + +bool operator>( const Long &a, int b ) +{ + return a.as_long() > b; +} + +bool operator>( const Long &a, long b ) +{ + return a.as_long() > b; +} + +bool operator>( int a, const Long &b ) +{ + return a > b.as_long(); +} + +bool operator>( long a, const Long &b ) +{ + return a > b.as_long(); +} + +//------------------------------ +bool operator>=( const Long &a, const Long &b ) +{ + return a.as_long() >= b.as_long(); +} + +bool operator>=( const Long &a, int b ) +{ + return a.as_long() >= b; +} + +bool operator>=( const Long &a, long b ) +{ + return a.as_long() >= b; +} + +bool operator>=( int a, const Long &b ) +{ + return a >= b.as_long(); +} + +bool operator>=( long a, const Long &b ) +{ + return a >= b.as_long(); +} + +//------------------------------ +bool operator<( const Long &a, const Long &b ) +{ + return a.as_long() < b.as_long(); +} + +bool operator<( const Long &a, int b ) +{ + return a.as_long() < b; +} + +bool operator<( const Long &a, long b ) +{ + return a.as_long() < b; +} + +bool operator<( int a, const Long &b ) +{ + return a < b.as_long(); +} + +bool operator<( long a, const Long &b ) +{ + return a < b.as_long(); +} + +//------------------------------ +bool operator<=( const Long &a, const Long &b ) +{ + return a.as_long() <= b.as_long(); +} + +bool operator<=( int a, const Long &b ) +{ + return a <= b.as_long(); +} + +bool operator<=( long a, const Long &b ) +{ + return a <= b.as_long(); +} + +bool operator<=( const Long &a, int b ) +{ + return a.as_long() <= b; +} + +bool operator<=( const Long &a, long b ) +{ + return a.as_long() <= b; +} + +#ifdef HAVE_LONG_LONG +//------------------------------ +bool operator!=( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() != b; +} + +bool operator!=( PY_LONG_LONG a, const Long &b ) +{ + return a != b.as_long_long(); +} + +//------------------------------ +bool operator==( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() == b; +} + +bool operator==( PY_LONG_LONG a, const Long &b ) +{ + return a == b.as_long_long(); +} + +//------------------------------ +bool operator>( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() > b; +} + +bool operator>( PY_LONG_LONG a, const Long &b ) +{ + return a > b.as_long_long(); +} + +//------------------------------ +bool operator>=( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() >= b; +} + +bool operator>=( PY_LONG_LONG a, const Long &b ) +{ + return a >= b.as_long_long(); +} + +//------------------------------ +bool operator<( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() < b; +} + +bool operator<( PY_LONG_LONG a, const Long &b ) +{ + return a < b.as_long_long(); +} + +//------------------------------ +bool operator<=( const Long &a, PY_LONG_LONG b ) +{ + return a.as_long_long() <= b; +} + +bool operator<=( PY_LONG_LONG a, const Long &b ) +{ + return a <= b.as_long_long(); +} +#endif +#endif + +//------------------------------------------------------------ +// compare operators +bool operator!=( const Float &a, const Float &b ) +{ + return a.as_double() != b.as_double(); +} + +bool operator!=( const Float &a, double b ) +{ + return a.as_double() != b; +} + +bool operator!=( double a, const Float &b ) +{ + return a != b.as_double(); +} + +//------------------------------ +bool operator==( const Float &a, const Float &b ) +{ + return a.as_double() == b.as_double(); +} + +bool operator==( const Float &a, double b ) +{ + return a.as_double() == b; +} + +bool operator==( double a, const Float &b ) +{ + return a == b.as_double(); +} + +//------------------------------ +bool operator>( const Float &a, const Float &b ) +{ + return a.as_double() > b.as_double(); +} + +bool operator>( const Float &a, double b ) +{ + return a.as_double() > b; +} + +bool operator>( double a, const Float &b ) +{ + return a > b.as_double(); +} + +//------------------------------ +bool operator>=( const Float &a, const Float &b ) +{ + return a.as_double() >= b.as_double(); +} + +bool operator>=( const Float &a, double b ) +{ + return a.as_double() >= b; +} + +bool operator>=( double a, const Float &b ) +{ + return a >= b.as_double(); +} + +//------------------------------ +bool operator<( const Float &a, const Float &b ) +{ + return a.as_double() < b.as_double(); +} + +bool operator<( const Float &a, double b ) +{ + return a.as_double() < b; +} + +bool operator<( double a, const Float &b ) +{ + return a < b.as_double(); +} + +//------------------------------ +bool operator<=( const Float &a, const Float &b ) +{ + return a.as_double() <= b.as_double(); +} + +bool operator<=( double a, const Float &b ) +{ + return a <= b.as_double(); +} + +bool operator<=( const Float &a, double b ) +{ + return a.as_double() <= b; +} + +} // end of namespace Py diff --git a/src/CXX/Python3/cxxextensions.c b/src/CXX/Python3/cxxextensions.c new file mode 100644 index 000000000..7feb1e0db --- /dev/null +++ b/src/CXX/Python3/cxxextensions.c @@ -0,0 +1,54 @@ +/*---------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//---------------------------------------------------------------------------*/ + +#include "CXX/WrapPython.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +PyObject py_object_initializer = + { + _PyObject_EXTRA_INIT + 1, + NULL // type must be init'ed by user + }; + +#ifdef __cplusplus +} +#endif diff --git a/src/CXX/Python3/cxxsupport.cxx b/src/CXX/Python3/cxxsupport.cxx new file mode 100644 index 000000000..442d932b2 --- /dev/null +++ b/src/CXX/Python3/cxxsupport.cxx @@ -0,0 +1,228 @@ +//----------------------------------------------------------------------------- +// +// Copyright (c) 1998 - 2007, The Regents of the University of California +// Produced at the Lawrence Livermore National Laboratory +// All rights reserved. +// +// This file is part of PyCXX. For details,see http://cxx.sourceforge.net/. The +// full copyright notice is contained in the file COPYRIGHT located at the root +// of the PyCXX distribution. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are met: +// +// - Redistributions of source code must retain the above copyright notice, +// this list of conditions and the disclaimer below. +// - Redistributions in binary form must reproduce the above copyright notice, +// this list of conditions and the disclaimer (as noted below) in the +// documentation and/or materials provided with the distribution. +// - Neither the name of the UC/LLNL nor the names of its contributors may be +// used to endorse or promote products derived from this software without +// specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +// ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OF THE UNIVERSITY OF +// CALIFORNIA, THE U.S. DEPARTMENT OF ENERGY OR CONTRIBUTORS BE LIABLE FOR +// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +// LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +// OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH +// DAMAGE. +// +//----------------------------------------------------------------------------- + +#include "CXX/Objects.hxx" +namespace Py +{ + +Py_UNICODE unicode_null_string[1] = { 0 }; + +Type Object::type() const +{ + return Type( PyObject_Type( p ), true ); +} + +String Object::str() const +{ + return String( PyObject_Str( p ), true ); +} + +String Object::repr() const +{ + return String( PyObject_Repr( p ), true ); +} + +std::string Object::as_string() const +{ + return static_cast( str() ); +} + +List Object::dir() const +{ + return List( PyObject_Dir( p ), true ); +} + +bool Object::isType( const Type &t ) const +{ + return type().ptr() == t.ptr(); +} + +Char::operator String() const +{ + return String( ptr() ); +} + +String Bytes::decode( const char *encoding, const char *error ) +{ + return String( PyUnicode_FromEncodedObject( ptr(), encoding, error ), true ); +} + +// Object compares +bool operator==( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_EQ ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; +} + +bool operator!=( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_NE ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; + +} + +bool operator>=( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_GE ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; +} + +bool operator<=( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_LE ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; +} + +bool operator<( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_LT ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; +} + +bool operator>( const Object &o1, const Object &o2 ) +{ + int k = PyObject_RichCompareBool( *o1, *o2, Py_GT ); + if( PyErr_Occurred() ) + throw Exception(); + return k != 0; +} + +// iterator compares +bool operator==( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.eql( right ); +} + +bool operator!=( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.neq( right ); +} + +bool operator<( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.lss( right ); +} + +bool operator>( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.gtr( right ); +} + +bool operator<=( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.leq( right ); +} + +bool operator>=( const Sequence::iterator &left, const Sequence::iterator &right ) +{ + return left.geq( right ); +} + +// const_iterator compares +bool operator==( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.eql( right ); +} + +bool operator!=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.neq( right ); +} + +bool operator<( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.lss( right ); +} + +bool operator>( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.gtr( right ); +} + +bool operator<=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.leq( right ); +} + +bool operator>=( const Sequence::const_iterator &left, const Sequence::const_iterator &right ) +{ + return left.geq( right ); +} + +// For mappings: +bool operator==( const Mapping::iterator &left, const Mapping::iterator &right ) +{ + return left.eql( right ); +} + +bool operator!=( const Mapping::iterator &left, const Mapping::iterator &right ) +{ + return left.neq( right ); +} + +// now for const_iterator +bool operator==( const Mapping::const_iterator &left, const Mapping::const_iterator &right ) +{ + return left.eql( right ); +} + +bool operator!=( const Mapping::const_iterator &left, const Mapping::const_iterator &right ) +{ + return left.neq( right ); +} + +// TMM: 31May'01 - Added the #ifndef so I can exclude iostreams. +#ifndef CXX_NO_IOSTREAMS +// output + +std::ostream &operator<<( std::ostream &os, const Object &ob ) +{ + return( os << static_cast( ob.str() ) ); +} +#endif + +} // Py diff --git a/src/CXX/Version.hxx b/src/CXX/Version.hxx index 219312577..f5a5d6536 100644 --- a/src/CXX/Version.hxx +++ b/src/CXX/Version.hxx @@ -40,7 +40,7 @@ #define PYCXX_VERSION_MAJOR 6 #define PYCXX_VERSION_MINOR 2 -#define PYCXX_VERSION_PATCH 0 +#define PYCXX_VERSION_PATCH 5 #define PYCXX_MAKEVERSION( major, minor, patch ) ((major<<16)|(minor<<8)|(patch)) #define PYCXX_VERSION PYCXX_MAKEVERSION( PYCXX_VERSION_MAJOR, PYCXX_VERSION_MINOR, PYCXX_VERSION_PATCH ) #endif diff --git a/src/CXX/WrapPython.h b/src/CXX/WrapPython.h index db159a503..6a73545d2 100644 --- a/src/CXX/WrapPython.h +++ b/src/CXX/WrapPython.h @@ -56,14 +56,16 @@ // pull in python definitions #include -#ifdef FC_OS_MACOSX -#undef toupper -#undef tolower + +// fix issue with Python assuming that isspace, toupper etc are macros +#if defined(isspace) +#undef isspace #undef isupper #undef islower -#undef isspace -#undef isalpha #undef isalnum +#undef isalpha +#undef toupper +#undef tolower #endif #endif diff --git a/src/CXX/cxxextensions.c b/src/CXX/cxxextensions.c index cfab556f0..28a8e1d38 100644 --- a/src/CXX/cxxextensions.c +++ b/src/CXX/cxxextensions.c @@ -37,7 +37,7 @@ #include "CXX/WrapPython.h" #if PY_MAJOR_VERSION == 2 -#include "Python2/cxxextensions.c" +#include "Src/Python2/cxxextensions.c" #else -#include "Python3/cxxextensions.c" +#include "Src/Python3/cxxextensions.c" #endif diff --git a/src/CXX/cxxsupport.cxx b/src/CXX/cxxsupport.cxx index 9f25d9891..1f2fb432d 100644 --- a/src/CXX/cxxsupport.cxx +++ b/src/CXX/cxxsupport.cxx @@ -34,10 +34,10 @@ // DAMAGE. // //----------------------------------------------------------------------------- -#include "WrapPython.h" +#include "CXX/WrapPython.h" #if PY_MAJOR_VERSION == 2 -#include "Python2/cxxsupport.cxx" +#include "Src/Python2/cxxsupport.cxx" #else -#include "Python3/cxxsupport.cxx" +#include "Src/Python3/cxxsupport.cxx" #endif