Upgraded PyCXX to version 6.2.5
This commit is contained in:
Yorik van Havre
parent
16e8b0ee3f
commit
ad3908cca6
|
|
@ -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 <windows.h>
|
||||
|
||||
|
||||
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
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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__
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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<TEMPLATE_TYPENAME T>
|
||||
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
|
||||
(
|
||||
|
|
|
|||
|
|
@ -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() );
|
||||
|
||||
|
|
|
|||
|
|
@ -113,7 +113,7 @@ namespace Py
|
|||
};
|
||||
|
||||
|
||||
class PYCXX_EXPORT ExtensionClassMethodsTable
|
||||
class ExtensionClassMethodsTable
|
||||
{
|
||||
public:
|
||||
ExtensionClassMethodsTable()
|
||||
|
|
|
|||
|
|
@ -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 & );
|
||||
|
|
|
|||
|
|
@ -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();
|
||||
|
|
|
|||
|
|
@ -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 <windows.h>
|
||||
|
||||
|
||||
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
|
||||
}
|
||||
|
|
@ -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__
|
||||
|
|
|
|||
|
|
@ -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<T>& 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<T>&>(obj))
|
||||
, offset( 0 )
|
||||
, offset( NULL )
|
||||
, the_item(s.getItem(offset))
|
||||
{}
|
||||
~seqref()
|
||||
|
|
@ -1449,7 +1449,7 @@ namespace Py
|
|||
protected:
|
||||
friend class SeqBase<T>;
|
||||
SeqBase<T>* seq;
|
||||
size_type count;
|
||||
int count;
|
||||
|
||||
public:
|
||||
~iterator ()
|
||||
|
|
@ -1460,7 +1460,7 @@ namespace Py
|
|||
, count( 0 )
|
||||
{}
|
||||
|
||||
iterator (SeqBase<T>* s, size_type where)
|
||||
iterator (SeqBase<T>* s, int where)
|
||||
: seq( s )
|
||||
, count( where )
|
||||
{}
|
||||
|
|
@ -1587,7 +1587,7 @@ namespace Py
|
|||
sequence_index_type count;
|
||||
|
||||
private:
|
||||
const_iterator (const SeqBase<T>* s, size_type where)
|
||||
const_iterator (const SeqBase<T>* s, int where)
|
||||
: seq( s )
|
||||
, count( where )
|
||||
{}
|
||||
|
|
@ -1724,19 +1724,19 @@ namespace Py
|
|||
template <TEMPLATE_TYPENAME T> bool operator<=(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& right);
|
||||
template <TEMPLATE_TYPENAME T> bool operator>=(const EXPLICIT_TYPENAME SeqBase<T>::const_iterator& left, const EXPLICIT_TYPENAME SeqBase<T>::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<Py_UNICODE> 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<Char>
|
||||
class String: public SeqBase<Char>
|
||||
{
|
||||
public:
|
||||
virtual size_type capacity() const
|
||||
|
|
@ -1889,13 +1889,6 @@ namespace Py
|
|||
validate();
|
||||
}
|
||||
|
||||
String( const std::string &v, std::string::size_type vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v.data()),
|
||||
static_cast<int>( vsize ) ), true)
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
String( const char *v, int vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v), vsize ), true )
|
||||
{
|
||||
|
|
@ -1989,7 +1982,7 @@ namespace Py
|
|||
}
|
||||
}
|
||||
};
|
||||
class PYCXX_EXPORT Bytes: public SeqBase<Char>
|
||||
class Bytes: public SeqBase<Char>
|
||||
{
|
||||
public:
|
||||
virtual size_type capacity() const
|
||||
|
|
@ -2019,12 +2012,6 @@ namespace Py
|
|||
validate();
|
||||
}
|
||||
|
||||
Bytes( const std::string& v, std::string::size_type vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v.data()), static_cast<int>( vsize ) ), true)
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
Bytes( const char *v, int vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(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<Char>
|
||||
class String: public SeqBase<Char>
|
||||
{
|
||||
public:
|
||||
virtual size_type capacity() const
|
||||
|
|
@ -2170,13 +2157,6 @@ namespace Py
|
|||
validate();
|
||||
}
|
||||
|
||||
String( const std::string& v, std::string::size_type vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(v.data()),
|
||||
static_cast<int>( vsize ) ), true)
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
String( const char *v, int vsize )
|
||||
: SeqBase<Char>(PyString_FromStringAndSize( const_cast<char*>(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<T>(*this, key);
|
||||
}
|
||||
|
||||
size_type length () const
|
||||
int length () const
|
||||
{
|
||||
return PyMapping_Length (ptr());
|
||||
}
|
||||
|
|
@ -2956,7 +2936,7 @@ namespace Py
|
|||
//
|
||||
MapBase<T>* map;
|
||||
List keys; // for iterating over the map
|
||||
size_type pos; // index into the keys
|
||||
int pos; // index into the keys
|
||||
|
||||
private:
|
||||
iterator( MapBase<T>* m, List k, int p )
|
||||
|
|
@ -3059,7 +3039,7 @@ namespace Py
|
|||
friend class MapBase<T>;
|
||||
const MapBase<T>* 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<T>* m, List k, int p )
|
||||
|
|
@ -3148,15 +3128,15 @@ namespace Py
|
|||
template <TEMPLATE_TYPENAME T> bool operator==(const EXPLICIT_TYPENAME MapBase<T>::const_iterator& left, const EXPLICIT_TYPENAME MapBase<T>::const_iterator& right);
|
||||
template <TEMPLATE_TYPENAME T> bool operator!=(const EXPLICIT_TYPENAME MapBase<T>::const_iterator& left, const EXPLICIT_TYPENAME MapBase<T>::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 );
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -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 );
|
||||
|
|
|
|||
|
|
@ -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<PyObject *>( table ) = py_object_initializer;
|
||||
#if !defined( PY3 )
|
||||
table->ob_type = _Type_Type();
|
||||
table->ob_size = 0;
|
||||
#endif
|
||||
|
||||
table->tp_name = const_cast<char *>( 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<ExtensionModuleBase *>( 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<ExtensionModuleBase *>( 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
|
||||
|
|
|
|||
117
src/CXX/Python3/Config.hxx
Normal file
117
src/CXX/Python3/Config.hxx
Normal file
|
|
@ -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<std::random_access_iterator_tag,itemtype,int>
|
||||
#else
|
||||
# define random_access_iterator_parent(itemtype) std::random_access_iterator<itemtype, int>
|
||||
#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 <strstream>
|
||||
# define TEMPLATE_TYPENAME class
|
||||
# else
|
||||
# define PYCXX_ISO_CPP_LIB 1
|
||||
# define STR_STREAM <sstream>
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
# endif
|
||||
#elif defined( __GNUC__ )
|
||||
# if __GNUC__ >= 3
|
||||
# define PYCXX_ISO_CPP_LIB 1
|
||||
# define STR_STREAM <sstream>
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
# else
|
||||
# define PYCXX_ISO_CPP_LIB 0
|
||||
# define STR_STREAM <strstream>
|
||||
# define TEMPLATE_TYPENAME class
|
||||
# endif
|
||||
#endif
|
||||
|
||||
#if PYCXX_ISO_CPP_LIB
|
||||
# define STR_STREAM <sstream>
|
||||
# define OSTRSTREAM ostringstream
|
||||
# define EXPLICIT_TYPENAME typename
|
||||
# define EXPLICIT_CLASS class
|
||||
# define TEMPLATE_TYPENAME typename
|
||||
#else
|
||||
# define STR_STREAM <strstream>
|
||||
# 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__
|
||||
17
src/CXX/Python3/CxxDebug.hxx
Normal file
17
src/CXX/Python3/CxxDebug.hxx
Normal file
|
|
@ -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
|
||||
260
src/CXX/Python3/Exception.hxx
Normal file
260
src/CXX/Python3/Exception.hxx
Normal file
|
|
@ -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 <string>
|
||||
#include <iostream>
|
||||
|
||||
// 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
|
||||
204
src/CXX/Python3/ExtensionModule.hxx
Normal file
204
src/CXX/Python3/ExtensionModule.hxx
Normal file
|
|
@ -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_<module> 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<TEMPLATE_TYPENAME T>
|
||||
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<std::string, MethodDefExt<T> *> 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<T>( 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<T>( 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<T>( 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<T> *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<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( 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<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( 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<T *>( this );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>( method_def );
|
||||
|
||||
return (self->*meth_def->ext_keyword_function)( args, keywords );
|
||||
}
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
ExtensionModule( const ExtensionModule<T> & ); //unimplemented
|
||||
void operator=( const ExtensionModule<T> & ); //unimplemented
|
||||
};
|
||||
} // Namespace Py
|
||||
|
||||
|
||||
// End of __CXX_ExtensionModule__h
|
||||
#endif
|
||||
398
src/CXX/Python3/ExtensionOldType.hxx
Normal file
398
src/CXX/Python3/ExtensionOldType.hxx
Normal file
|
|
@ -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<TEMPLATE_TYPENAME T> 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<std::string, MethodDefExt<T> *> 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<T> *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<T>( 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<T>( 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<T>( 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<T *>( self_in_cobject );
|
||||
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
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<T *>( self_in_cobject );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
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<T *>( self_in_cobject );
|
||||
MethodDefExt<T> *meth_def = reinterpret_cast<MethodDefExt<T> *>(
|
||||
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<T> &other );
|
||||
void operator=( const PythonExtension<T> &rhs );
|
||||
};
|
||||
|
||||
//
|
||||
// ExtensionObject<T> is an Object that will accept only T's.
|
||||
//
|
||||
template<TEMPLATE_TYPENAME T>
|
||||
class ExtensionObject: public Object
|
||||
{
|
||||
public:
|
||||
|
||||
explicit ExtensionObject( PyObject *pyob )
|
||||
: Object( pyob )
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
ExtensionObject( const ExtensionObject<T> &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<T *>( ptr() );
|
||||
}
|
||||
};
|
||||
} // Namespace Py
|
||||
|
||||
// End of __CXX_ExtensionOldType__h
|
||||
#endif
|
||||
403
src/CXX/Python3/ExtensionType.hxx
Normal file
403
src/CXX/Python3/ExtensionType.hxx
Normal file
|
|
@ -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; i<m_methods_used; i++ )
|
||||
{
|
||||
if( name == m_methods_table[i].ml_name )
|
||||
{
|
||||
throw AttributeError( name );
|
||||
}
|
||||
}
|
||||
}
|
||||
PyMethodDef *add_method( const char *name, PyCFunction function, int flags, const char *doc )
|
||||
{
|
||||
check_unique_method_name( name );
|
||||
|
||||
// see if there is enough space for one more method
|
||||
if( m_methods_used == (m_methods_size-1) )
|
||||
{
|
||||
PyMethodDef *old_mt = m_methods_table;
|
||||
m_methods_size += METHOD_TABLE_SIZE_INCREMENT;
|
||||
PyMethodDef *new_mt = new PyMethodDef[ m_methods_size ];
|
||||
for( int i=0; i<m_methods_used; i++ )
|
||||
{
|
||||
new_mt[ i ] = old_mt[ i ];
|
||||
}
|
||||
delete[] old_mt;
|
||||
m_methods_table = new_mt;
|
||||
}
|
||||
|
||||
// add method into the table
|
||||
PyMethodDef *p = &m_methods_table[ m_methods_used ];
|
||||
p->ml_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<TEMPLATE_TYPENAME T> 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<PythonClassInstance *>( subtype->tp_alloc( subtype, 0 ) );
|
||||
if( o == NULL )
|
||||
return NULL;
|
||||
|
||||
o->m_pycxx_object = NULL;
|
||||
|
||||
PyObject *self = reinterpret_cast<PyObject *>( 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<PythonClassInstance *>( _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<PyObject *>( 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<PyObject *>( m_class_instance );
|
||||
}
|
||||
|
||||
virtual Object self()
|
||||
{
|
||||
return Object( reinterpret_cast<PyObject *>( m_class_instance ) );
|
||||
}
|
||||
|
||||
protected:
|
||||
private:
|
||||
PythonClassInstance *m_class_instance;
|
||||
|
||||
private:
|
||||
//
|
||||
// prevent the compiler generating these unwanted functions
|
||||
//
|
||||
explicit PythonClass( const PythonClass<T> &other );
|
||||
void operator=( const PythonClass<T> &rhs );
|
||||
};
|
||||
|
||||
//
|
||||
// ExtensionObject<T> is an Object that will accept only T's.
|
||||
//
|
||||
template<TEMPLATE_TYPENAME T>
|
||||
class PythonClassObject: public Object
|
||||
{
|
||||
public:
|
||||
|
||||
explicit PythonClassObject( PyObject *pyob )
|
||||
: Object( pyob )
|
||||
{
|
||||
validate();
|
||||
}
|
||||
|
||||
PythonClassObject( const PythonClassObject<T> &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
|
||||
170
src/CXX/Python3/ExtensionTypeBase.hxx
Normal file
170
src/CXX/Python3/ExtensionTypeBase.hxx
Normal file
|
|
@ -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
|
||||
189
src/CXX/Python3/Extensions.hxx
Normal file
189
src/CXX/Python3/Extensions.hxx
Normal file
|
|
@ -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 <vector>
|
||||
#include <map>
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
|
||||
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<PyMethodDef> 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 T>
|
||||
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<char *>( _name );
|
||||
ext_meth_def.ml_meth = reinterpret_cast<method_varargs_call_handler_t>( _handler );
|
||||
ext_meth_def.ml_flags = METH_NOARGS;
|
||||
ext_meth_def.ml_doc = const_cast<char *>( _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<char *>( _name );
|
||||
ext_meth_def.ml_meth = reinterpret_cast<method_varargs_call_handler_t>( _handler );
|
||||
ext_meth_def.ml_flags = METH_VARARGS;
|
||||
ext_meth_def.ml_doc = const_cast<char *>( _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<char *>( _name );
|
||||
ext_meth_def.ml_meth = reinterpret_cast<method_varargs_call_handler_t>( _handler );
|
||||
ext_meth_def.ml_flags = METH_VARARGS|METH_KEYWORDS;
|
||||
ext_meth_def.ml_doc = const_cast<char *>( _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
|
||||
183
src/CXX/Python3/IndirectPythonInterface.hxx
Normal file
183
src/CXX/Python3/IndirectPythonInterface.hxx
Normal file
|
|
@ -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__
|
||||
3426
src/CXX/Python3/Objects.hxx
Normal file
3426
src/CXX/Python3/Objects.hxx
Normal file
File diff suppressed because it is too large
Load Diff
114
src/CXX/Python3/PythonType.hxx
Normal file
114
src/CXX/Python3/PythonType.hxx
Normal file
|
|
@ -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
|
||||
1977
src/CXX/Python3/cxx_extensions.cxx
Normal file
1977
src/CXX/Python3/cxx_extensions.cxx
Normal file
File diff suppressed because it is too large
Load Diff
54
src/CXX/Python3/cxxextensions.c
Normal file
54
src/CXX/Python3/cxxextensions.c
Normal file
|
|
@ -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
|
||||
228
src/CXX/Python3/cxxsupport.cxx
Normal file
228
src/CXX/Python3/cxxsupport.cxx
Normal file
|
|
@ -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<std::string>( 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<std::string>( ob.str() ) );
|
||||
}
|
||||
#endif
|
||||
|
||||
} // Py
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -56,14 +56,16 @@
|
|||
|
||||
// pull in python definitions
|
||||
#include <Python.h>
|
||||
#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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user