Merged the Python 3.0 support branch. The merging progress is not so smooth, so hope this commit won't make anything broken.
This is the (incomplemete) log produced by svnmerge.py: Merged revisions 10405-10409,10420-10422,10426,10438,10445,10451,10454-10465,10467,10473-10475,10485,10488-10489,10493-10495,10497,10509-10510,10513-10514,10517,10520,10525,10528-10529,10533-10535,10554-10557,10570,10573,10593,10614,10666-10669,10673,10678,10687,10690,10704-10706,10731,10744,10750-10752,10755,10759,10770,10775-10776,10813,10819 via svnmerge from https://swig.svn.sourceforge.net/svnroot/swig/branches/gsoc2008-bhy git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@10834 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Haoyu Bai
parent
761ef2b98f
commit
3d8ddfc442
75 changed files with 1603 additions and 246 deletions
|
|
@ -20,11 +20,13 @@ SWIG_AsValFilePtr(PyObject *obj, FILE **val) {
|
|||
if ((SWIG_ConvertPtr(obj, &vptr, desc, 0)) == SWIG_OK) {
|
||||
if (val) *val = (FILE *)vptr;
|
||||
return SWIG_OK;
|
||||
}
|
||||
}
|
||||
%#if PY_VERSION_HEX < 0x03000000
|
||||
if (PyFile_Check(obj)) {
|
||||
if (val) *val = PyFile_AsFile(obj);
|
||||
return SWIG_OK;
|
||||
}
|
||||
%#endif
|
||||
return SWIG_TypeError;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
10
Lib/python/pyabc.i
Normal file
10
Lib/python/pyabc.i
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
%define %pythonabc(Type, Abc)
|
||||
%feature("python:abc", #Abc) Type;
|
||||
%enddef
|
||||
%pythoncode {import collections};
|
||||
%pythonabc(std::vector, collections.MutableSequence);
|
||||
%pythonabc(std::list, collections.MutableSequence);
|
||||
%pythonabc(std::map, collections.MutableMapping);
|
||||
%pythonabc(std::multimap, collections.MutableMapping);
|
||||
%pythonabc(std::set, collections.MutableSet);
|
||||
%pythonabc(std::multiset, collections.MutableSet);
|
||||
|
|
@ -27,6 +27,20 @@ typedef struct swig_const_info {
|
|||
swig_type_info **ptype;
|
||||
} swig_const_info;
|
||||
|
||||
|
||||
/* -----------------------------------------------------------------------------
|
||||
* Wrapper of PyInstanceMethod_New() used in Python 3
|
||||
* It is exported to the generated module, used for -fastproxy
|
||||
* ----------------------------------------------------------------------------- */
|
||||
SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *self, PyObject *func)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
return PyInstanceMethod_New(func);
|
||||
#else
|
||||
return NULL;
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
#if 0
|
||||
{ /* cc-mode */
|
||||
|
|
|
|||
107
Lib/python/pybuffer.i
Normal file
107
Lib/python/pybuffer.i
Normal file
|
|
@ -0,0 +1,107 @@
|
|||
/* Impelementing buffer protocol typemaps */
|
||||
|
||||
/* %pybuffer_mutable_binary(TYPEMAP, SIZE)
|
||||
*
|
||||
* Macro for functions accept mutable buffer pointer with a size.
|
||||
* This can be used for both input and output. For example:
|
||||
*
|
||||
* %pybuffer_mutable_binary(char *buff, int size);
|
||||
* void foo(char *buff, int size) {
|
||||
* for(int i=0; i<size; ++i)
|
||||
* buff[i]++;
|
||||
* }
|
||||
*/
|
||||
|
||||
%define %pybuffer_mutable_binary(TYPEMAP, SIZE)
|
||||
%typemap(in) (TYPEMAP, SIZE)
|
||||
(int res, Py_ssize_t size = 0, void *buf = 0) {
|
||||
res = PyObject_AsWriteBuffer($input, &buf, &size);
|
||||
if (res<0) {
|
||||
PyErr_Clear();
|
||||
%argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
|
||||
}
|
||||
$1 = ($1_ltype) buf;
|
||||
$2 = ($2_ltype) size;
|
||||
}
|
||||
%enddef
|
||||
|
||||
/* %pybuffer_mutable_string(TYPEMAP, SIZE)
|
||||
*
|
||||
* Macro for functions accept mutable zero terminated string pointer.
|
||||
* This can be used for both input and output. For example:
|
||||
*
|
||||
* %pybuffer_mutable_string(char *str);
|
||||
* void foo(char *str) {
|
||||
* while(*str) {
|
||||
* *str = toupper(*str);
|
||||
* str++;
|
||||
* }
|
||||
*/
|
||||
|
||||
%define %pybuffer_mutable_string(TYPEMAP)
|
||||
%typemap(in) (TYPEMAP)
|
||||
(int res, Py_ssize_t size = 0, void *buf = 0) {
|
||||
res = PyObject_AsWriteBuffer($input, &buf, &size);
|
||||
if (res<0) {
|
||||
PyErr_Clear();
|
||||
%argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
|
||||
}
|
||||
$1 = ($1_ltype) buf;
|
||||
}
|
||||
%enddef
|
||||
|
||||
/* pybuffer_binary(TYPEMAP, SIZE)
|
||||
*
|
||||
* Macro for functions accept read only buffer pointer with a size.
|
||||
* This must be used for input. For example:
|
||||
*
|
||||
* %pybuffer_binary(char *buff, int size);
|
||||
* int foo(char *buff, int size) {
|
||||
* int count = 0;
|
||||
* for(int i=0; i<size; ++i)
|
||||
* if (0==buff[i]) count++;
|
||||
* return count;
|
||||
* }
|
||||
*/
|
||||
|
||||
%define %pybuffer_binary(TYPEMAP, SIZE)
|
||||
%typemap(in) (TYPEMAP, SIZE)
|
||||
(int res, Py_ssize_t size = 0, const void *buf = 0) {
|
||||
res = PyObject_AsReadBuffer($input, &buf, &size);
|
||||
if (res<0) {
|
||||
PyErr_Clear();
|
||||
%argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
|
||||
}
|
||||
$1 = ($1_ltype) buf;
|
||||
$2 = ($2_ltype) size;
|
||||
}
|
||||
%enddef
|
||||
|
||||
/* %pybuffer_string(TYPEMAP, SIZE)
|
||||
*
|
||||
* Macro for functions accept read only zero terminated string pointer.
|
||||
* This can be used for input. For example:
|
||||
*
|
||||
* %pybuffer_string(char *str);
|
||||
* int foo(char *str) {
|
||||
* int count = 0;
|
||||
* while(*str) {
|
||||
* if (isalnum(*str))
|
||||
* count++;
|
||||
* str++;
|
||||
* }
|
||||
*/
|
||||
|
||||
%define %pybuffer_string(TYPEMAP)
|
||||
%typemap(in) (TYPEMAP)
|
||||
(int res, Py_ssize_t size = 0, const void *buf = 0) {
|
||||
res = PyObject_AsReadBuffer($input, &buf, &size);
|
||||
if (res<0) {
|
||||
%argument_fail(res, "(TYPEMAP, SIZE)", $symname, $argnum);
|
||||
}
|
||||
$1 = ($1_ltype) buf;
|
||||
}
|
||||
%enddef
|
||||
|
||||
|
||||
|
||||
|
|
@ -116,6 +116,17 @@ namespace std {
|
|||
bool res;
|
||||
SWIG_PYTHON_THREAD_BEGIN_BLOCK;
|
||||
res = PyObject_Compare(v, w) < 0;
|
||||
/* This may fall into a case of inconsistent
|
||||
eg. ObjA > ObjX > ObjB
|
||||
but ObjA < ObjB
|
||||
*/
|
||||
if( PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_TypeError) )
|
||||
{
|
||||
/* Objects can't be compared, this mostly occured in Python 3.0 */
|
||||
/* Compare their ptr directly for a workaround */
|
||||
res = (v < w);
|
||||
PyErr_Clear();
|
||||
}
|
||||
SWIG_PYTHON_THREAD_END_BLOCK;
|
||||
return res;
|
||||
}
|
||||
|
|
@ -597,6 +608,11 @@ namespace swig
|
|||
return !(self->empty());
|
||||
}
|
||||
|
||||
/* Alias for Python 3 compatibility */
|
||||
bool __bool__() const {
|
||||
return !(self->empty());
|
||||
}
|
||||
|
||||
size_type __len__() const {
|
||||
return self->size();
|
||||
}
|
||||
|
|
@ -618,6 +634,14 @@ namespace swig
|
|||
return x;
|
||||
}
|
||||
|
||||
/* typemap for slice object support */
|
||||
%typemap(in) PySliceObject* {
|
||||
$1 = (PySliceObject *) $input;
|
||||
}
|
||||
%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER) PySliceObject* {
|
||||
$1 = PySlice_Check($input);
|
||||
}
|
||||
|
||||
Sequence* __getslice__(difference_type i, difference_type j) throw (std::out_of_range) {
|
||||
return swig::getslice(self, i, j);
|
||||
}
|
||||
|
|
@ -634,6 +658,43 @@ namespace swig
|
|||
void __delitem__(difference_type i) throw (std::out_of_range) {
|
||||
self->erase(swig::getpos(self,i));
|
||||
}
|
||||
|
||||
|
||||
/* Overloaded methods for Python 3 compatibility
|
||||
* (Also useful in Python 2.x)
|
||||
*/
|
||||
Sequence* __getitem__(PySliceObject *slice) throw (std::out_of_range) {
|
||||
Py_ssize_t i, j, step;
|
||||
if( !PySlice_Check(slice) ) {
|
||||
SWIG_Error(SWIG_TypeError, "Slice object expected.");
|
||||
return NULL;
|
||||
}
|
||||
PySlice_GetIndices(slice, self->size(), &i, &j, &step);
|
||||
return swig::getslice(self, i, j);
|
||||
}
|
||||
|
||||
void __setitem__(PySliceObject *slice, const Sequence& v)
|
||||
throw (std::out_of_range, std::invalid_argument) {
|
||||
Py_ssize_t i, j, step;
|
||||
if( !PySlice_Check(slice) ) {
|
||||
SWIG_Error(SWIG_TypeError, "Slice object expected.");
|
||||
return;
|
||||
}
|
||||
PySlice_GetIndices(slice, self->size(), &i, &j, &step);
|
||||
swig::setslice(self, i, j, v);
|
||||
}
|
||||
|
||||
void __delitem__(PySliceObject *slice)
|
||||
throw (std::out_of_range) {
|
||||
Py_ssize_t i, j, step;
|
||||
if( !PySlice_Check(slice) ) {
|
||||
SWIG_Error(SWIG_TypeError, "Slice object expected.");
|
||||
return;
|
||||
}
|
||||
PySlice_GetIndices(slice, self->size(), &i, &j, &step);
|
||||
swig::delslice(self, i,j);
|
||||
}
|
||||
|
||||
}
|
||||
%enddef
|
||||
|
||||
|
|
|
|||
|
|
@ -58,12 +58,12 @@ SWIG_Python_AddErrorMsg(const char* mesg)
|
|||
PyObject *old_str = PyObject_Str(value);
|
||||
PyErr_Clear();
|
||||
Py_XINCREF(type);
|
||||
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
|
||||
|
||||
PyErr_Format(type, "%s %s",
|
||||
SWIG_Python_str_AsChar(old_str), mesg);
|
||||
Py_DECREF(old_str);
|
||||
Py_DECREF(value);
|
||||
} else {
|
||||
PyErr_SetString(PyExc_RuntimeError, mesg);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -1,3 +1,47 @@
|
|||
/* Compatibility marcos for Python 3 */
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
|
||||
#define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
|
||||
|
||||
#define PyInt_Check(x) PyLong_Check(x)
|
||||
#define PyInt_AsLong(x) PyLong_AsLong(x)
|
||||
#define PyInt_FromLong(x) PyLong_FromLong(x)
|
||||
|
||||
#define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
|
||||
#endif
|
||||
|
||||
#ifndef Py_TYPE
|
||||
# define Py_TYPE(op) ((op)->ob_type)
|
||||
#endif
|
||||
|
||||
/* SWIG APIs for compatibility of boht Python 2 & 3 */
|
||||
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
# define SWIG_Python_str_FromFormat PyUnicode_FromFormat
|
||||
#else
|
||||
# define SWIG_Python_str_FromFormat PyString_FromFormat
|
||||
#endif
|
||||
|
||||
SWIGINTERN char*
|
||||
SWIG_Python_str_AsChar(PyObject *str)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
str = PyUnicode_AsUTF8String(str);
|
||||
return PyBytes_AsString(str);
|
||||
#else
|
||||
return PyString_AsString(str);
|
||||
#endif
|
||||
}
|
||||
|
||||
SWIGINTERN PyObject*
|
||||
SWIG_Python_str_FromChar(const char *c)
|
||||
{
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
return PyUnicode_FromString(c);
|
||||
#else
|
||||
return PyString_FromString(c);
|
||||
#endif
|
||||
}
|
||||
|
||||
/* Add PyOS_snprintf for old Pythons */
|
||||
#if PY_VERSION_HEX < 0x02020000
|
||||
|
|
|
|||
|
|
@ -33,18 +33,48 @@ typedef struct swig_varlinkobject {
|
|||
|
||||
SWIGINTERN PyObject *
|
||||
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
return PyUnicode_InternFromString("<Swig global variables>");
|
||||
#else
|
||||
return PyString_FromString("<Swig global variables>");
|
||||
#endif
|
||||
}
|
||||
|
||||
SWIGINTERN PyObject *
|
||||
swig_varlink_str(swig_varlinkobject *v) {
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyObject *str = PyUnicode_InternFromString("(");
|
||||
PyObject *tail;
|
||||
PyObject *joined;
|
||||
swig_globalvar *var;
|
||||
for (var = v->vars; var; var=var->next) {
|
||||
tail = PyUnicode_FromString(var->name);
|
||||
joined = PyUnicode_Concat(str, tail);
|
||||
Py_DecRef(str);
|
||||
Py_DecRef(tail);
|
||||
str = joined;
|
||||
if (var->next) {
|
||||
tail = PyUnicode_InternFromString(", ");
|
||||
joined = PyUnicode_Concat(str, tail);
|
||||
Py_DecRef(str);
|
||||
Py_DecRef(tail);
|
||||
str = joined;
|
||||
}
|
||||
}
|
||||
tail = PyUnicode_InternFromString(")");
|
||||
joined = PyUnicode_Concat(str, tail);
|
||||
Py_DecRef(str);
|
||||
Py_DecRef(tail);
|
||||
str = joined;
|
||||
#else
|
||||
PyObject *str = PyString_FromString("(");
|
||||
swig_globalvar *var;
|
||||
swig_globalvar *var;
|
||||
for (var = v->vars; var; var=var->next) {
|
||||
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
|
||||
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
|
||||
}
|
||||
PyString_ConcatAndDel(&str,PyString_FromString(")"));
|
||||
#endif
|
||||
return str;
|
||||
}
|
||||
|
||||
|
|
@ -52,7 +82,7 @@ SWIGINTERN int
|
|||
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
|
||||
PyObject *str = swig_varlink_str(v);
|
||||
fprintf(fp,"Swig global variables ");
|
||||
fprintf(fp,"%s\n", PyString_AsString(str));
|
||||
fprintf(fp,"%s\n", SWIG_Python_str_AsChar(str));
|
||||
Py_DECREF(str);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -110,8 +140,13 @@ swig_varlink_type(void) {
|
|||
if (!type_init) {
|
||||
const PyTypeObject tmp
|
||||
= {
|
||||
/* PyObject header changed in Python 3 */
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
||||
#else
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0, /* Number of items in variable part (ob_size) */
|
||||
#endif
|
||||
(char *)"swigvarlink", /* Type name (tp_name) */
|
||||
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
|
||||
0, /* Itemsize (tp_itemsize) */
|
||||
|
|
@ -147,7 +182,10 @@ swig_varlink_type(void) {
|
|||
#endif
|
||||
};
|
||||
varlink_type = tmp;
|
||||
/* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
varlink_type.ob_type = &PyType_Type;
|
||||
#endif
|
||||
type_init = 1;
|
||||
}
|
||||
return &varlink_type;
|
||||
|
|
@ -272,13 +310,35 @@ SWIG_Python_FixMethods(PyMethodDef *methods,
|
|||
#ifdef __cplusplus
|
||||
extern "C"
|
||||
#endif
|
||||
SWIGEXPORT void SWIG_init(void) {
|
||||
|
||||
SWIGEXPORT
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyObject*
|
||||
#else
|
||||
void
|
||||
#endif
|
||||
SWIG_init(void) {
|
||||
PyObject *m, *d;
|
||||
|
||||
/* Fix SwigMethods to carry the callback ptrs when needed */
|
||||
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
|
||||
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
static struct PyModuleDef SWIG_module = {
|
||||
PyModuleDef_HEAD_INIT,
|
||||
(char *) SWIG_name,
|
||||
NULL,
|
||||
-1,
|
||||
SwigMethods,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
m = PyModule_Create(&SWIG_module);
|
||||
#else
|
||||
m = Py_InitModule((char *) SWIG_name, SwigMethods);
|
||||
#endif
|
||||
d = PyModule_GetDict(m);
|
||||
|
||||
SWIG_InitializeModule(0);
|
||||
|
|
|
|||
|
|
@ -66,6 +66,12 @@ namespace swig {
|
|||
return obj;
|
||||
}
|
||||
|
||||
/* Make an alias for Python 3.x */
|
||||
PyObject *__next__()
|
||||
{
|
||||
return next();
|
||||
}
|
||||
|
||||
PyObject *previous()
|
||||
{
|
||||
SWIG_PYTHON_THREAD_BEGIN_BLOCK; // disable threads
|
||||
|
|
@ -335,6 +341,7 @@ namespace swig
|
|||
%catches(swig::stop_iteration) PySwigIterator::decr(size_t n = 1);
|
||||
%catches(std::invalid_argument) PySwigIterator::distance(const PySwigIterator &x) const;
|
||||
%catches(std::invalid_argument) PySwigIterator::equal (const PySwigIterator &x) const;
|
||||
%catches(swig::stop_iteration) PySwigIterator::__next__();
|
||||
%catches(swig::stop_iteration) PySwigIterator::next();
|
||||
%catches(swig::stop_iteration) PySwigIterator::previous();
|
||||
%catches(swig::stop_iteration) PySwigIterator::advance(ptrdiff_t n);
|
||||
|
|
@ -370,6 +377,7 @@ namespace swig
|
|||
virtual PySwigIterator *copy() const = 0;
|
||||
|
||||
PyObject *next();
|
||||
PyObject *__next__();
|
||||
PyObject *previous();
|
||||
PySwigIterator *advance(ptrdiff_t n);
|
||||
|
||||
|
|
|
|||
|
|
@ -33,6 +33,12 @@
|
|||
/* Special cases */
|
||||
%rename(__invert__) *::operator~;
|
||||
%rename(__call__) *::operator();
|
||||
|
||||
%feature("shadow") *::operator bool %{
|
||||
def __nonzero__(self):
|
||||
return $action(self)
|
||||
__bool__ = __nonzero__
|
||||
%};
|
||||
%rename(__nonzero__) *::operator bool;
|
||||
|
||||
/* Ignored operators */
|
||||
|
|
|
|||
|
|
@ -348,9 +348,13 @@ PySwigObject_format(const char* fmt, PySwigObject *v)
|
|||
PyObject *args = PyTuple_New(1);
|
||||
if (args) {
|
||||
if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
|
||||
PyObject *ofmt = PyString_FromString(fmt);
|
||||
PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
|
||||
if (ofmt) {
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
res = PyUnicode_Format(ofmt,args);
|
||||
#else
|
||||
res = PyString_Format(ofmt,args);
|
||||
#endif
|
||||
Py_DECREF(ofmt);
|
||||
}
|
||||
Py_DECREF(args);
|
||||
|
|
@ -380,7 +384,7 @@ PySwigObject_repr(PySwigObject *v, PyObject *args)
|
|||
{
|
||||
const char *name = SWIG_TypePrettyName(v->ty);
|
||||
PyObject *hex = PySwigObject_hex(v);
|
||||
PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
|
||||
PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at 0x%U>", name, hex);
|
||||
Py_DECREF(hex);
|
||||
if (v->next) {
|
||||
#ifdef METH_NOARGS
|
||||
|
|
@ -388,7 +392,14 @@ PySwigObject_repr(PySwigObject *v, PyObject *args)
|
|||
#else
|
||||
PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyObject *joined = PyUnicode_Concat(repr, nrep);
|
||||
Py_DecRef(repr);
|
||||
Py_DecRef(nrep);
|
||||
repr = joined;
|
||||
#else
|
||||
PyString_ConcatAndDel(&repr,nrep);
|
||||
#endif
|
||||
}
|
||||
return repr;
|
||||
}
|
||||
|
|
@ -402,7 +413,7 @@ PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
|
|||
PyObject *repr = PySwigObject_repr(v, NULL);
|
||||
#endif
|
||||
if (repr) {
|
||||
fputs(PyString_AsString(repr), fp);
|
||||
fputs(SWIG_Python_str_AsChar(repr), fp);
|
||||
Py_DECREF(repr);
|
||||
return 0;
|
||||
} else {
|
||||
|
|
@ -415,7 +426,7 @@ PySwigObject_str(PySwigObject *v)
|
|||
{
|
||||
char result[SWIG_BUFFER_SIZE];
|
||||
return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
|
||||
PyString_FromString(result) : 0;
|
||||
SWIG_Python_str_FromChar(result) : 0;
|
||||
}
|
||||
|
||||
SWIGRUNTIME int
|
||||
|
|
@ -426,6 +437,24 @@ PySwigObject_compare(PySwigObject *v, PySwigObject *w)
|
|||
return (i < j) ? -1 : ((i > j) ? 1 : 0);
|
||||
}
|
||||
|
||||
/* Added for Python 3.x, whould it also useful for Python 2.x? */
|
||||
SWIGRUNTIME PyObject*
|
||||
PySwigObject_richcompare(PySwigObject *v, PySwigObject *w, int op)
|
||||
{
|
||||
PyObject* res;
|
||||
if( op != Py_EQ && op != Py_NE ) {
|
||||
Py_INCREF(Py_NotImplemented);
|
||||
return Py_NotImplemented;
|
||||
}
|
||||
if( (PySwigObject_compare(v, w)==0) == (op == Py_EQ) )
|
||||
res = Py_True;
|
||||
else
|
||||
res = Py_False;
|
||||
Py_INCREF(res);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
|
||||
|
||||
SWIGRUNTIME PyTypeObject*
|
||||
|
|
@ -436,8 +465,8 @@ PySwigObject_type(void) {
|
|||
|
||||
SWIGRUNTIMEINLINE int
|
||||
PySwigObject_Check(PyObject *op) {
|
||||
return ((op)->ob_type == PySwigObject_type())
|
||||
|| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
|
||||
return (Py_TYPE(op) == PySwigObject_type())
|
||||
|| (strcmp(Py_TYPE(op)->tp_name,"PySwigObject") == 0);
|
||||
}
|
||||
|
||||
SWIGRUNTIME PyObject *
|
||||
|
|
@ -610,7 +639,10 @@ _PySwigObject_type(void) {
|
|||
(binaryfunc)0, /*nb_add*/
|
||||
(binaryfunc)0, /*nb_subtract*/
|
||||
(binaryfunc)0, /*nb_multiply*/
|
||||
/* nb_divide removed in Python 3 */
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
(binaryfunc)0, /*nb_divide*/
|
||||
#endif
|
||||
(binaryfunc)0, /*nb_remainder*/
|
||||
(binaryfunc)0, /*nb_divmod*/
|
||||
(ternaryfunc)0,/*nb_power*/
|
||||
|
|
@ -624,13 +656,19 @@ _PySwigObject_type(void) {
|
|||
0, /*nb_and*/
|
||||
0, /*nb_xor*/
|
||||
0, /*nb_or*/
|
||||
(coercion)0, /*nb_coerce*/
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
0, /*nb_coerce*/
|
||||
#endif
|
||||
(unaryfunc)PySwigObject_long, /*nb_int*/
|
||||
(unaryfunc)PySwigObject_long, /*nb_long*/
|
||||
(unaryfunc)0, /*nb_float*/
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
(unaryfunc)PySwigObject_oct, /*nb_oct*/
|
||||
(unaryfunc)PySwigObject_hex, /*nb_hex*/
|
||||
#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
|
||||
#endif
|
||||
#if PY_VERSION_HEX >= 0x03000000 /* 3.0 */
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
|
||||
#elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
|
||||
#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
|
||||
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
|
||||
|
|
@ -644,8 +682,13 @@ _PySwigObject_type(void) {
|
|||
if (!type_init) {
|
||||
const PyTypeObject tmp
|
||||
= {
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0, /* ob_size */
|
||||
/* PyOjbect header changed in Python 3 */
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
||||
#else
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0, /* ob_size */
|
||||
#endif
|
||||
(char *)"PySwigObject", /* tp_name */
|
||||
sizeof(PySwigObject), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
|
|
@ -672,7 +715,7 @@ _PySwigObject_type(void) {
|
|||
swigobject_doc, /* tp_doc */
|
||||
0, /* tp_traverse */
|
||||
0, /* tp_clear */
|
||||
0, /* tp_richcompare */
|
||||
(richcmpfunc)PySwigObject_richcompare, /* tp_richcompare */
|
||||
0, /* tp_weaklistoffset */
|
||||
#if PY_VERSION_HEX >= 0x02020000
|
||||
0, /* tp_iter */
|
||||
|
|
@ -704,7 +747,10 @@ _PySwigObject_type(void) {
|
|||
#endif
|
||||
};
|
||||
pyswigobject_type = tmp;
|
||||
/* for Python 3 we already assigned the ob_type in PyVarObject_HEAD_INIT() */
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
pyswigobject_type.ob_type = &PyType_Type;
|
||||
#endif
|
||||
type_init = 1;
|
||||
}
|
||||
return &pyswigobject_type;
|
||||
|
|
@ -753,9 +799,9 @@ PySwigPacked_repr(PySwigPacked *v)
|
|||
{
|
||||
char result[SWIG_BUFFER_SIZE];
|
||||
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
|
||||
return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
|
||||
return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
|
||||
} else {
|
||||
return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
|
||||
return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -764,9 +810,9 @@ PySwigPacked_str(PySwigPacked *v)
|
|||
{
|
||||
char result[SWIG_BUFFER_SIZE];
|
||||
if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
|
||||
return PyString_FromFormat("%s%s", result, v->ty->name);
|
||||
return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
|
||||
} else {
|
||||
return PyString_FromString(v->ty->name);
|
||||
return SWIG_Python_str_FromChar(v->ty->name);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -811,8 +857,13 @@ _PySwigPacked_type(void) {
|
|||
if (!type_init) {
|
||||
const PyTypeObject tmp
|
||||
= {
|
||||
/* PyObject header changed in Python 3 */
|
||||
#if PY_VERSION_HEX>=0x03000000
|
||||
PyVarObject_HEAD_INIT(&PyType_Type, 0)
|
||||
#else
|
||||
PyObject_HEAD_INIT(NULL)
|
||||
0, /* ob_size */
|
||||
0, /* ob_size */
|
||||
#endif
|
||||
(char *)"PySwigPacked", /* tp_name */
|
||||
sizeof(PySwigPacked), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
|
|
@ -867,7 +918,10 @@ _PySwigPacked_type(void) {
|
|||
#endif
|
||||
};
|
||||
pyswigpacked_type = tmp;
|
||||
/* for Python 3 the ob_type already assigned in PyVarObject_HEAD_INIT() */
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
pyswigpacked_type.ob_type = &PyType_Type;
|
||||
#endif
|
||||
type_init = 1;
|
||||
}
|
||||
return &pyswigpacked_type;
|
||||
|
|
@ -912,7 +966,7 @@ PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
|
|||
SWIGRUNTIMEINLINE PyObject *
|
||||
_SWIG_This(void)
|
||||
{
|
||||
return PyString_FromString("this");
|
||||
return SWIG_Python_str_FromChar("this");
|
||||
}
|
||||
|
||||
SWIGRUNTIME PyObject *
|
||||
|
|
@ -924,6 +978,11 @@ SWIG_This(void)
|
|||
|
||||
/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
|
||||
|
||||
/* TODO: I don't know how to implement the fast getset in Python 3 right now */
|
||||
#if PY_VERSION_HEX>=0x03000000
|
||||
#define SWIG_PYTHON_SLOW_GETSET_THIS
|
||||
#endif
|
||||
|
||||
SWIGRUNTIME PySwigObject *
|
||||
SWIG_Python_GetSwigThis(PyObject *pyobj)
|
||||
{
|
||||
|
|
@ -1161,10 +1220,17 @@ SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
|
|||
#endif
|
||||
}
|
||||
} else {
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
inst = PyBaseObject_Type.tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
|
||||
Py_INCREF(data->newargs);
|
||||
PyObject_SetAttr(inst, SWIG_This(), swig_this);
|
||||
Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
|
||||
#else
|
||||
PyObject *dict = PyDict_New();
|
||||
PyDict_SetItem(dict, SWIG_This(), swig_this);
|
||||
inst = PyInstance_NewRaw(data->newargs, dict);
|
||||
Py_DECREF(dict);
|
||||
#endif
|
||||
}
|
||||
return inst;
|
||||
#else
|
||||
|
|
@ -1344,8 +1410,13 @@ SWIGRUNTIME void
|
|||
SWIG_Python_SetModule(swig_module_info *swig_module) {
|
||||
static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
|
||||
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
/* Add a dummy module object into sys.modules */
|
||||
PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
|
||||
#else
|
||||
PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
|
||||
swig_empty_runtime_method_table);
|
||||
#endif
|
||||
PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
|
||||
if (pointer && module) {
|
||||
PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
|
||||
|
|
@ -1365,7 +1436,7 @@ SWIGRUNTIME swig_type_info *
|
|||
SWIG_Python_TypeQuery(const char *type)
|
||||
{
|
||||
PyObject *cache = SWIG_Python_TypeCache();
|
||||
PyObject *key = PyString_FromString(type);
|
||||
PyObject *key = SWIG_Python_str_FromChar(type);
|
||||
PyObject *obj = PyDict_GetItem(cache, key);
|
||||
swig_type_info *descriptor;
|
||||
if (obj) {
|
||||
|
|
@ -1403,9 +1474,9 @@ SWIG_Python_AddErrMesg(const char* mesg, int infront)
|
|||
Py_XINCREF(type);
|
||||
PyErr_Clear();
|
||||
if (infront) {
|
||||
PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
|
||||
PyErr_Format(type, "%s %s", mesg, SWIG_Python_str_AsChar(old_str));
|
||||
} else {
|
||||
PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
|
||||
PyErr_Format(type, "%s %s", SWIG_Python_str_AsChar(old_str), mesg);
|
||||
}
|
||||
Py_DECREF(old_str);
|
||||
}
|
||||
|
|
@ -1454,7 +1525,7 @@ SWIG_Python_TypeError(const char *type, PyObject *obj)
|
|||
const char *otype = (obj ? obj->ob_type->tp_name : 0);
|
||||
if (otype) {
|
||||
PyObject *str = PyObject_Str(obj);
|
||||
const char *cstr = str ? PyString_AsString(str) : 0;
|
||||
const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
|
||||
if (cstr) {
|
||||
PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
|
||||
type, otype, cstr);
|
||||
|
|
|
|||
|
|
@ -5,10 +5,20 @@
|
|||
SWIGINTERN int
|
||||
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
|
||||
{
|
||||
if (PyString_Check(obj)) {
|
||||
%#if PY_VERSION_HEX>=0x03000000
|
||||
if (PyUnicode_Check(obj))
|
||||
%#else
|
||||
if (PyString_Check(obj))
|
||||
%#endif
|
||||
{
|
||||
char *cstr; Py_ssize_t len;
|
||||
%#if PY_VERSION_HEX>=0x03000000
|
||||
obj = PyUnicode_AsUTF8String(obj);
|
||||
PyBytes_AsStringAndSize(obj, &cstr, &len);
|
||||
%#else
|
||||
PyString_AsStringAndSize(obj, &cstr, &len);
|
||||
if (cptr) {
|
||||
%#endif
|
||||
if (cptr) {
|
||||
if (alloc) {
|
||||
/*
|
||||
In python the user should not be able to modify the inner
|
||||
|
|
@ -33,7 +43,7 @@ SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
|
|||
*alloc = SWIG_OLDOBJ;
|
||||
}
|
||||
} else {
|
||||
*cptr = PyString_AsString(obj);
|
||||
*cptr = SWIG_Python_str_AsChar(obj);
|
||||
}
|
||||
}
|
||||
if (psize) *psize = len + 1;
|
||||
|
|
@ -64,7 +74,11 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
|
|||
return pchar_descriptor ?
|
||||
SWIG_NewPointerObj(%const_cast(carray,char *), pchar_descriptor, 0) : SWIG_Py_Void();
|
||||
} else {
|
||||
%#if PY_VERSION_HEX >= 0x03000000
|
||||
return PyUnicode_FromStringAndSize(carray, %numeric_cast(size,int));
|
||||
%#else
|
||||
return PyString_FromStringAndSize(carray, %numeric_cast(size,int));
|
||||
%#endif
|
||||
}
|
||||
} else {
|
||||
return SWIG_Py_Void();
|
||||
|
|
|
|||
|
|
@ -8,12 +8,14 @@ SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
|
|||
{
|
||||
PyObject *tmp = 0;
|
||||
int isunicode = PyUnicode_Check(obj);
|
||||
%#if PY_VERSION_HEX < 0x03000000
|
||||
if (!isunicode && PyString_Check(obj)) {
|
||||
if (cptr) {
|
||||
obj = tmp = PyUnicode_FromObject(obj);
|
||||
}
|
||||
isunicode = 1;
|
||||
}
|
||||
%#endif
|
||||
if (isunicode) {
|
||||
int len = PyUnicode_GetSize(obj);
|
||||
if (cptr) {
|
||||
|
|
|
|||
|
|
@ -22,6 +22,10 @@
|
|||
int res = SWIG_ERROR;
|
||||
if (PyDict_Check(obj)) {
|
||||
PyObject_var items = PyObject_CallMethod(obj,(char *)"items",NULL);
|
||||
%#if PY_VERSION_HEX >= 0x03000000
|
||||
/* In Python 3.x the ".items()" method return a dict_items object */
|
||||
items = PySequence_Fast(items, ".items() havn't returned a sequence!");
|
||||
%#endif
|
||||
res = traits_asptr_stdseq<std::map<K,T>, std::pair<K, T> >::asptr(items, val);
|
||||
} else {
|
||||
map_type *p;
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue