XS-MLVP
/
swig
mirror of https://github.com/swig/swig
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

- recover the proper catching exception mechanism for classes 

(throw typemap).

- fix the examples with exception problems and warnings

- proper and consist treatment of basic types (short, unsigned char,...)

  now all are checked for range and sign. Before, this was depending of
  the use of parsing or no parsing, and/or the converter method, and/or
  the use of directors, etc.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@5659 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Marcelo Matus 2004-01-21 01:15:10 +00:00
parent 5078783796
commit 54737ee9a9
8 changed files with 459 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Examples/python/exception/example.h
View File

@ -1,6 +1,10 @@
/* File : example.h */ /* File : example.h */
#include <string> #include <string>
#ifndef SWIG
struct A {
};
#endif
class Exc { class Exc {
public: public:
@ -22,6 +26,9 @@ public:
} }
int hosed() throw(Exc) { int hosed() throw(Exc) {
throw(Exc(42,"Hosed")); throw(Exc(42,"Hosed"));
}
int unknown() throw(A) {
throw A();
} }
int multi(int x) throw(int, const char *, Exc) { int multi(int x) throw(int, const char *, Exc) {
if (x == 1) throw(37); if (x == 1) throw(37);

7
Examples/python/exception/runme.py
View File

@ -5,6 +5,11 @@
import example import example
t = example.Test() t = example.Test()
try:
t.unknown()
except RuntimeError,e:
print "incomplete type", e.args[0]
try: try:
t.simple() t.simple()
except RuntimeError,e: except RuntimeError,e:
@ -27,3 +32,5 @@ for i in range(1,4):
print e.args[0] print e.args[0]
except example.Exc,e: except example.Exc,e:
print e.code, e.msg print e.code, e.msg

2
Examples/python/operator/example.i
View File

@ -1,6 +1,6 @@
/* File : example.i */ /* File : example.i */
%module example %module example
#pragma SWIG nowarn=362
%{ %{
#include "example.h" #include "example.h"
%} %}

2
Examples/python/varargs/example.i
View File

@ -21,7 +21,7 @@ int printf(const char *fmt, ...);
%varargs(char *) fprintf; %varargs(char *) fprintf;
/* Ignore the format string, but set it to %s */ /* Ignore the format string, but set it to %s */
%typemap(ignore) const char *fmt { %typemap(in,numinputs=0) const char *fmt {
$1 = "%s"; $1 = "%s";
} }
#else #else

3
Examples/python/variables/example.i
View File

@ -1,5 +1,6 @@
/* File : example.i */ /* File : example.i */
%module example %module example
#pragma SWIG nowarn=451
%{ %{
#include "example.h" #include "example.h"
%} %}
@ -17,7 +18,7 @@ extern char cvar;
extern float fvar; extern float fvar;
extern double dvar; extern double dvar;
extern char *strvar; extern char *strvar;
extern const char *cstrvar; extern const char * cstrvar;
extern int *iptrvar; extern int *iptrvar;
extern char name[256]; extern char name[256];

20
Examples/test-suite/python/exception_order_runme.py
View File

@ -1,21 +1,21 @@
import exception_order from exception_order import *
a = exception_order.A() a = A()
try: try:
a.foo() a.foo()
except RuntimeError,e: except E1,e:
if e.args[0] != "E1": pass
print "bad exception order", except:
raise RuntimeError, e.args raise RuntimeError, "bad exception order"
try: try:
a.bar() a.bar()
except RuntimeError,e: except E2,e:
if e.args[0] != "E2": pass
print "bad exception order", except:
raise RuntimeError, e.args raise RuntimeError, "bad exception order"
try: try:
a.foobar() a.foobar()

168
Lib/python/pyrun.swg
View File

@ -10,6 +10,172 @@
#include "Python.h" #include "Python.h"
#include <limits.h>
#include <float.h>
#ifdef __cplusplus
#define SWIG_STATIC_INLINE static inline
#else
#define SWIG_STATIC_INLINE static
#endif
SWIG_STATIC_INLINE long
SPyObj_AsLong(PyObject * obj)
{
return PyInt_Check(obj) ? PyInt_AsLong(obj) : PyLong_AsLong(obj);
}
SWIG_STATIC_INLINE unsigned long
SPyObj_AsUnsignedLong(PyObject * obj)
{
if (PyLong_Check(obj)) {
return PyLong_AsUnsignedLong(obj);
} else {
long i = PyInt_AsLong(obj);
if ( !PyErr_Occurred() && (i < 0)) {
PyErr_SetString(PyExc_TypeError, "negative value for unsigned type");
}
return i;
}
}
SWIG_STATIC_INLINE PyObject*
SPyObj_FromLongLong(long long value)
{
return (value > (long)(LONG_MAX)) ?
PyLong_FromLongLong(value) : PyInt_FromLong((long)value);
}
SWIG_STATIC_INLINE PyObject*
SPyObj_FromUnsignedLong(unsigned long value)
{
return (value > (unsigned long)(LONG_MAX)) ?
PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)value);
}
SWIG_STATIC_INLINE PyObject*
SPyObj_FromUnsignedLongLong(unsigned long long value)
{
return (value > (unsigned long long)(LONG_MAX)) ?
PyLong_FromUnsignedLongLong(value) : PyInt_FromLong((long)value);
}
SWIG_STATIC_INLINE long
SPyObj_AsLongInRange(PyObject * obj, long min_value, long max_value)
{
long value = SPyObj_AsLong(obj);
if (!PyErr_Occurred()) {
if (value < min_value) {
PyErr_SetString(PyExc_OverflowError,"value is smaller than type minimum");
} else if (value > max_value) {
PyErr_SetString(PyExc_OverflowError,"value is greater than type maximum");
}
}
return value;
}
SWIG_STATIC_INLINE unsigned long
SPyObj_AsUnsignedLongInRange(PyObject *obj, unsigned long max_value)
{
unsigned long value = SPyObj_AsUnsignedLong(obj);
if (!PyErr_Occurred()) {
if (value > max_value) {
PyErr_SetString(PyExc_OverflowError,"value is greater than type maximum");
}
}
return value;
}
SWIG_STATIC_INLINE signed char
SPyObj_AsSignedChar(PyObject *obj) {
return SPyObj_AsLongInRange(obj, SCHAR_MIN, SCHAR_MAX);
}
SWIG_STATIC_INLINE short
SPyObj_AsShort(PyObject *obj) {
return SPyObj_AsLongInRange(obj, SHRT_MIN, SHRT_MAX);
}
SWIG_STATIC_INLINE int
SPyObj_AsInt(PyObject *obj) {
return SPyObj_AsLongInRange(obj, INT_MIN, INT_MAX);
}
SWIG_STATIC_INLINE unsigned char
SPyObj_AsUnsignedChar(PyObject *obj) {
return SPyObj_AsUnsignedLongInRange(obj, UCHAR_MAX);
}
SWIG_STATIC_INLINE unsigned short
SPyObj_AsUnsignedShort(PyObject *obj) {
return SPyObj_AsUnsignedLongInRange(obj, USHRT_MAX);
}
SWIG_STATIC_INLINE unsigned int
SPyObj_AsUnsignedInt(PyObject *obj) {
return SPyObj_AsUnsignedLongInRange(obj, UINT_MAX);
}
SWIG_STATIC_INLINE long long
SPyObj_AsLongLong(PyObject *obj) {
return PyInt_Check(obj) ?
PyInt_AsLong(obj) : PyLong_AsLongLong(obj);
}
SWIG_STATIC_INLINE unsigned long long
SPyObj_AsUnsignedLongLong(PyObject *obj) {
return PyLong_Check(obj) ?
PyLong_AsUnsignedLongLong(obj) : SPyObj_AsUnsignedLong(obj);
}
SWIG_STATIC_INLINE double
SPyObj_AsDouble(PyObject *obj) {
return (PyFloat_Check(obj)) ? PyFloat_AsDouble(obj) :
(double)((PyInt_Check(obj)) ? PyInt_AsLong(obj) : PyLong_AsLongLong(obj));
}
SWIG_STATIC_INLINE float
SPyObj_AsFloat(PyObject *obj) {
double value = SPyObj_AsDouble(obj);
if (!PyErr_Occurred()) {
if (value < FLT_MIN) {
PyErr_SetString(PyExc_OverflowError,"float is smaller than flt_min");
} else if (value > FLT_MAX) {
PyErr_SetString(PyExc_OverflowError,"float is greater than flt_max");
}
}
return (float) value;
}
SWIG_STATIC_INLINE char
SPyObj_AsChar(PyObject *obj) {
char c = (PyString_Check(obj) && PyString_Size(obj) == 1) ?
PyString_AsString(obj)[0]
: (char) SPyObj_AsLongInRange(obj, CHAR_MIN, CHAR_MAX);
if (PyErr_Occurred()) {
PyErr_Clear();
PyErr_SetString(PyExc_TypeError, "a char is required");
}
return c;
}
SWIG_STATIC_INLINE PyObject *
SPyObj_FromChar(char c) {
return PyString_FromStringAndSize(&c,1);
}
SWIG_STATIC_INLINE PyObject *
SPyObj_FromCharPtr(const char* cptr) {
return cptr ? PyString_FromString(cptr) : Py_BuildValue((char*)"");
}
SWIG_STATIC_INLINE int
SPyObj_AsBool(PyObject *obj) {
return SPyObj_AsLongLong(obj) ? 1 : 0;
}
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
@ -45,7 +211,7 @@ typedef struct swig_const_info {
SWIG_Python_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
#define SWIG_MustGetPtr(p, type, argnum, flags) \ #define SWIG_MustGetPtr(p, type, argnum, flags) \
SWIG_Python_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
/* Python-specific SWIG API */ /* Python-specific SWIG API */
#define SWIG_newvarlink() \ #define SWIG_newvarlink() \
SWIG_Python_newvarlink() SWIG_Python_newvarlink()

493
Lib/python/python.swg
View File

@ -27,37 +27,34 @@
/* --- Input arguments --- */ /* --- Input arguments --- */
/* Primitive datatypes. These only supply a parse code to PyTuple_ParseArgs */ /* Primitive datatypes. These only supply a parse code to PyTuple_ParseArgs */
%typemap(in,parse="i") int "";
%typemap(in,parse="h") short ""; %typemap(in,parse="h") short "";
%typemap(in,parse="i") int "";
%typemap(in,parse="l") long ""; %typemap(in,parse="l") long "";
%typemap(in,parse="b") signed char "";
%typemap(in) unsigned int, unsigned short, unsigned long, unsigned char
"$1 = ($1_ltype) PyInt_AsLong($input);
if (PyErr_Occurred()) SWIG_fail;";
%typemap(in) long long
"$1 = ($1_ltype) PyLong_AsLongLong($input);
if (PyErr_Occurred()) SWIG_fail;";
%typemap(in) unsigned long long
"$1 = ($1_ltype) PyLong_AsUnsignedLongLong($input);
if (PyErr_Occurred()) SWIG_fail;";
%typemap(in,parse="f") float ""; %typemap(in,parse="f") float "";
%typemap(in,parse="d") double ""; %typemap(in,parse="d") double "";
%typemap(in,parse="c") char ""; %typemap(in,parse="c") char "";
%typemap(in,parse="s") char *, char [ANY] ""; %typemap(in,parse="s") char *, char [ANY] "";
/* Boolean values. Have to convert from a long since */ %define %typemapin_pyfunc(type, pyfunc)
%typemap(in) bool "$1 = PyInt_AsLong($input) ? true : false; %typemap(in) type {
if (PyErr_Occurred()) SWIG_fail;"; $1 = ($1_type) pyfunc($input);
if (PyErr_Occurred()) SWIG_fail;
}
%enddef
%typemapin_pyfunc(bool, SPyObj_AsBool);
%typemapin_pyfunc(signed char, SPyObj_AsSignedChar);
%typemapin_pyfunc(unsigned char, SPyObj_AsUnsignedChar);
%typemapin_pyfunc(unsigned short, SPyObj_AsUnsignedShort);
%typemapin_pyfunc(unsigned int, SPyObj_AsUnsignedInt);
%typemapin_pyfunc(unsigned long, SPyObj_AsUnsignedLong);
%typemapin_pyfunc(long long, SPyObj_AsLongLong);
%typemapin_pyfunc(unsigned long long, SPyObj_AsUnsignedLongLong);
/* Enum values. */
%typemap(in,parse="i") enum SWIGTYPE "";
/* Pointers, references, and arrays */ /* Pointers, references, and arrays */
%typemap(in) SWIGTYPE *, %typemap(in) SWIGTYPE *,
@ -84,60 +81,53 @@
/* Const primitive references. Passed by value */ /* Const primitive references. Passed by value */
%typemap(in) const int & (int temp), %define %typemapin_pyfunc_cr(type, pyfunc)
const short & (short temp), %typemap(in) const type& ($*1_ltype temp) {
const long & (long temp), temp = ($*1_ltype) pyfunc($input);
const unsigned int & (unsigned int temp), if (PyErr_Occurred()) SWIG_fail;
const unsigned short & (unsigned short temp), $1 = &temp;
const unsigned long & (unsigned long temp), }
const signed char & (signed char temp), %enddef
const unsigned char & (unsigned char temp)
"temp = ($*1_ltype) PyInt_AsLong($input);
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;";
%typemap(in) const bool & (bool temp) %typemapin_pyfunc_cr(bool, SPyObj_AsBool);
"temp = PyInt_AsLong($input) ? true : false; %typemapin_pyfunc_cr(signed char, SPyObj_AsSignedChar);
if (PyErr_Occurred()) SWIG_fail; %typemapin_pyfunc_cr(int, SPyObj_AsInt);
$1 = &temp;"; %typemapin_pyfunc_cr(short, SPyObj_AsShort);
%typemapin_pyfunc_cr(long, SPyObj_AsLong);
%typemapin_pyfunc_cr(unsigned char, SPyObj_AsUnsignedChar);
%typemapin_pyfunc_cr(unsigned short, SPyObj_AsUnsignedShort);
%typemapin_pyfunc_cr(unsigned int, SPyObj_AsUnsignedInt);
%typemapin_pyfunc_cr(unsigned long, SPyObj_AsUnsignedLong);
%typemap(in) const float & (float temp), %typemapin_pyfunc_cr(long long, SPyObj_AsLongLong);
const double & (double temp) %typemapin_pyfunc_cr(unsigned long long, SPyObj_AsUnsignedLongLong);
"temp = ($*1_ltype) PyFloat_AsDouble($input);
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;";
%typemap(in) const long long & ($*1_ltype temp) %typemapin_pyfunc_cr(float, SPyObj_AsFloat);
"temp = ($*1_ltype) PyLong_AsLongLong($input); %typemapin_pyfunc_cr(double, SPyObj_AsDouble);
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;";
%typemap(in) const unsigned long long & ($*1_ltype temp) %typemapin_pyfunc_cr(char, SPyObj_AsChar);
"temp = ($*1_ltype) PyLong_AsUnsignedLongLong($input); %typemapin_pyfunc_cr(char*, PyString_AsString);
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;";
%typemap(in) const char &(char temp) {
char *stemp = PyString_AsString($input);
if (PyErr_Occurred()) SWIG_fail;
temp = *stemp;
$1 = &temp;
}
/* --- Output values --- */ /* --- Output values --- */
%typemap(out) int, unsigned int, %typemap(out) bool,
short, unsigned short, signed char,
long, unsigned long, short,
signed char, unsigned char, unsigned char,
bool, enum SWIGTYPE unsigned short,
int,
long
"$result = PyInt_FromLong((long)$1);"; "$result = PyInt_FromLong((long)$1);";
%typemap(out) long long "$result = PyLong_FromLongLong($1);"; %typemap(out) unsigned int, unsigned long
%typemap(out) unsigned long long "$result = PyLong_FromUnsignedLongLong($1);"; "$result = SPyObj_FromUnsignedLong((unsigned long)$1);";
%typemap(out) long long "$result = SPyObj_FromLongLong($1);";
%typemap(out) unsigned long long "$result = SPyObj_FromUnsignedLongLong($1);";
%typemap(out) float, double "$result = PyFloat_FromDouble($1);"; %typemap(out) float, double "$result = PyFloat_FromDouble($1);";
%typemap(out) char * "$result = $1 ? PyString_FromString($1) : Py_BuildValue((char*)\"\");"; %typemap(out) char * "$result = SPyObj_FromCharPtr($1);";
%typemap(out) char "$result = Py_BuildValue((char*)\"c\",$1);"; %typemap(out) char "$result = SPyObj_FromChar($1);";
/* Pointers, references, and arrays */ /* Pointers, references, and arrays */
%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner);"; %typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner);";
@ -177,86 +167,68 @@
/* References to primitive types. Return by value */ /* References to primitive types. Return by value */
%typemap(out) const int &, const unsigned int &, %typemap(out) const bool &,
const short &, const unsigned short &, const signed char &,
const long &, const unsigned long &, const short &,
const signed char &, const unsigned char &, const unsigned char &,
const bool & const unsigned short &,
const int &,
const long &
"$result = PyInt_FromLong((long) *($1));"; "$result = PyInt_FromLong((long) *($1));";
%typemap(out) const unsigned int &, const unsigned long &
"$result = SPyObj_FromUnsignedLong((unsigned long) *($1));";
%typemap(out) const float &, const double & %typemap(out) const float &, const double &
"$result = PyFloat_FromDouble((double) *($1));"; "$result = PyFloat_FromDouble((double) *($1));";
%typemap(out) const long long & %typemap(out) const long long &
"$result = PyLong_FromLongLong(*($1));"; "$result = SPyObj_FromLongLong(*($1));";
%typemap(out) const unsigned long long & %typemap(out) const unsigned long long &
"$result = PyLong_FromUnsignedLongLong(*($1));"; "$result = SPyObj_FromUnsignedLongLong(*($1));";
%typemap(out) const char & %typemap(out) const char &
"$result = PyString_FromStringAndSize($1,1);"; "$result = SPyObj_FromChar(*($1));";
%typemap(out) const char* &
"$result = SPyObj_FromCharPtr(*($1));";
/* --- Variable input --- */ /* --- Variable input --- */
%typemap(varin) int, unsigned int, short, unsigned short, long, unsigned long, signed char, unsigned char, enum SWIGTYPE %define %typemapvarin_pyfunc(type, pyfunc)
{ %typemap(varin) type {
long temp = PyInt_AsLong($input); $1_type temp = ($1_type) pyfunc($input);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'"); PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1; return 1;
} }
$1 = ($1_type) temp; $1 = temp;
} }
%enddef
%typemap(varin) bool %typemapvarin_pyfunc(bool, SPyObj_AsBool);
{ %typemapvarin_pyfunc(signed char, SPyObj_AsSignedChar);
long temp = PyInt_AsLong($input); %typemapvarin_pyfunc(int, SPyObj_AsInt);
if (PyErr_Occurred()) { %typemapvarin_pyfunc(short, SPyObj_AsShort);
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'"); %typemapvarin_pyfunc(long, SPyObj_AsLong);
return 1; %typemapvarin_pyfunc(unsigned char, SPyObj_AsUnsignedChar);
} %typemapvarin_pyfunc(unsigned short, SPyObj_AsUnsignedShort);
$1 = temp ? true : false; %typemapvarin_pyfunc(unsigned int, SPyObj_AsUnsignedInt);
} %typemapvarin_pyfunc(unsigned long, SPyObj_AsUnsignedLong);
%typemap(varin) long long { %typemapvarin_pyfunc(long long, SPyObj_AsLongLong);
$1_type temp = PyLong_AsLongLong($input); %typemapvarin_pyfunc(unsigned long long, SPyObj_AsUnsignedLongLong);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = temp;
}
%typemap(varin) unsigned long long { %typemapvarin_pyfunc(float, SPyObj_AsFloat);
$1_type temp = PyLong_AsUnsignedLongLong($input); %typemapvarin_pyfunc(double, SPyObj_AsDouble);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = temp;
}
%typemap(varin) float, double {
double temp = PyFloat_AsDouble($input);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = ($1_ltype) temp;
}
/* A single character */ /* A single character */
%typemap(varin) char { %typemapvarin_pyfunc(char, SPyObj_AsChar);
char *temp = PyString_AsString($input);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = *temp;
}
/* A string */ /* A string */
#ifdef __cplusplus #ifdef __cplusplus
%typemap(varin) char * { %typemap(varin) char * {
char *temp = (char *) PyString_AsString($input); char *temp = (char *) PyString_AsString($input);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -267,6 +239,7 @@
$1 = ($type) new char[strlen(temp)+1]; $1 = ($type) new char[strlen(temp)+1];
strcpy((char*)$1,temp); strcpy((char*)$1,temp);
} }
%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * { %typemap(varin,warning="451:Setting const char * variable may leak memory") const char * {
char *temp = (char *) PyString_AsString($input); char *temp = (char *) PyString_AsString($input);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -276,7 +249,9 @@
$1 = ($type) new char[strlen(temp)+1]; $1 = ($type) new char[strlen(temp)+1];
strcpy((char*)$1,temp); strcpy((char*)$1,temp);
} }
#else #else
%typemap(varin) char * { %typemap(varin) char * {
char *temp = (char *) PyString_AsString($input); char *temp = (char *) PyString_AsString($input);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -287,6 +262,7 @@
$1 = ($type) malloc(strlen(temp)+1); $1 = ($type) malloc(strlen(temp)+1);
strcpy((char*)$1,temp); strcpy((char*)$1,temp);
} }
%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * { %typemap(varin,warning="451:Setting const char * variable may leak memory") const char * {
char *temp = (char *) PyString_AsString($input); char *temp = (char *) PyString_AsString($input);
if (PyErr_Occurred()) { if (PyErr_Occurred()) {
@ -296,6 +272,7 @@
$1 = ($type) malloc(strlen(temp)+1); $1 = ($type) malloc(strlen(temp)+1);
strcpy((char*)$1,temp); strcpy((char*)$1,temp);
} }
#endif #endif
%typemap(varin) SWIGTYPE [ANY] { %typemap(varin) SWIGTYPE [ANY] {
@ -367,18 +344,23 @@
/* --- Variable output --- */ /* --- Variable output --- */
%typemap(varout) int, unsigned int, %typemap(varout) bool,
short, unsigned short, signed char,
long, unsigned long, short,
signed char, unsigned char, unsigned char,
bool, enum SWIGTYPE unsigned short,
int,
long
"$result = PyInt_FromLong((long)$1);"; "$result = PyInt_FromLong((long)$1);";
%typemap(varout) long long "$result = PyLong_FromLongLong($1);"; %typemap(varout) unsigned int, unsigned long
%typemap(varout) unsigned long long "$result = PyLong_FromUnsignedLongLong($1);"; "$result = SPyObj_FromUnsignedLong((unsigned long)$1);";
%typemap(varout) long long "$result = SPyObj_FromLongLong($1);";
%typemap(varout) unsigned long long "$result = SPyObj_FromUnsignedLongLong($1);";
%typemap(varout) float, double "$result = PyFloat_FromDouble($1);"; %typemap(varout) float, double "$result = PyFloat_FromDouble($1);";
%typemap(varout) char * "$result = $1 ? PyString_FromString($1) : Py_BuildValue((char*)\"\");"; %typemap(varout) char * "$result = SPyObj_FromCharPtr($1);";
%typemap(varout) char "$result = Py_BuildValue((char*)\"c\",$1);"; %typemap(varout) char "$result = SPyObj_FromChar($1);";
/* Pointers and arrays */ /* Pointers and arrays */
%typemap(varout) SWIGTYPE *, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, 0);"; %typemap(varout) SWIGTYPE *, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, 0);";
@ -399,7 +381,7 @@
/* --- Constants --- */ /* --- Constants --- */
%typemap(consttab) int, unsigned int, short, unsigned short, long, unsigned long, unsigned char, signed char, bool, enum SWIGTYPE %typemap(consttab) bool, signed char, short, int, long, unsigned char, unsigned short
{ SWIG_PY_INT, (char *)"$symname", (long) $value, 0, 0, 0} { SWIG_PY_INT, (char *)"$symname", (long) $value, 0, 0, 0}
%typemap(consttab) float, double %typemap(consttab) float, double
@ -414,8 +396,14 @@
%typemap(consttab) SWIGTYPE (CLASS::*) %typemap(consttab) SWIGTYPE (CLASS::*)
{ SWIG_PY_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor} { SWIG_PY_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
%typemap(constcode) long long "PyDict_SetItemString(d,\"$symname\", PyLong_FromLongLong($value));"; %typemap(constcode) unsigned int, unsigned long
%typemap(constcode) unsigned long long "PyDict_SetItemString(d,\"$symname\", PyLong_FromUnsignedLongLong($value));"; "PyDict_SetItemString(d,\"$symname\", SPyObj_FromUnsignedLong($value));";
%typemap(constcode) long long
"PyDict_SetItemString(d,\"$symname\", SPyObj_FromLongLong($value));";
%typemap(constcode) unsigned long long
"PyDict_SetItemString(d,\"$symname\", SPyObj_FromUnsignedLongLong($value));";
@ -429,56 +417,53 @@
/* directorin typemaps */ /* directorin typemaps */
/* Primitive datatypes. These only supply a parse code to PyObject_CallMethod */ /* Primitive datatypes. These only supply a parse code to PyObject_CallMethod */
%define %typemapdirectorin_pyfunc(type, _pyfunc)
%typemap(directorin) _type "$input = _pyfunc(($1_ltype) $1_name);";
%typemap(directorin) _type "$input = _pyfunc(($*1_ltype) $1_name);";
%enddef
%typemap(directorin,parse="i") int ""; %define %typemapdirectorin_parse(_type, _parse)
%typemap(directorin,parse="h") short ""; %typemap(directorin,parse=_parse) _type "($1_ltype) $1_name";
%typemap(directorin,parse="l") long ""; %typemap(directorin,parse=_parse) const _type& "($*1_ltype) $1_name";
%typemap(directorin,parse="b") signed char ""; %enddef
%typemap(directorin,parse="f") float "";
%typemap(directorin,parse="d") double "";
%typemap(directorin,parse="s") char* "";
%typemap(directorin,parse="i") bool "";
%typemap(directorin,parse="i") enum SWIGTYPE "";
%typemap(directorin,parse="l") unsigned int, unsigned short, %typemapdirectorin_parse(bool, "i");
unsigned long, unsigned char "(long) $1_name"; %typemapdirectorin_parse(signed char, "i");
%typemapdirectorin_parse(unsigned char, "i");
%typemapdirectorin_parse(short, "i");
%typemapdirectorin_parse(unsigned short, "i");
%typemapdirectorin_parse(int, "i");
%typemapdirectorin_parse(long, "l");
%typemapdirectorin_parse(float, "f");
%typemap(directorin) long long %typemapdirectorin_parse(double, "d");
"$input = PyLong_FromLongLong($1_name);"; %typemapdirectorin_parse(char, "c");
%typemap(directorin) unsigned long long %typemapdirectorin_parse(char*, "s");
"$input = PyLong_FromUnsignedLongLong($1_name);";
%typemap(directorin,parse="i") const int& ""; %typemapdirectorin_pyfunc(unsigned int, SPyObj_FromUnsignedLong);
%typemap(directorin,parse="h") const short& ""; %typemapdirectorin_pyfunc(unsigned long, SPyObj_FromUnsignedLong);
%typemap(directorin,parse="l") const long& ""; %typemapdirectorin_pyfunc(long long, SPyObj_FromLongLong);
%typemap(directorin,parse="b") const signed char& ""; %typemapdirectorin_pyfunc(unsigned long long, SPyObj_FromUnsignedLongLong);
%typemap(directorin,parse="f") const float& "";
%typemap(directorin,parse="d") const double& "";
%typemap(directorin,parse="i") const bool& "";
%typemap(directorin,parse="l") const unsigned int&,
const unsigned short&, const unsigned long&,
const unsigned char& "(long) $1_name";
%typemap(directorin) const long long&
"$input = PyLong_FromLongLong($1_name);";
%typemap(directorin) const unsigned long long&
"$input = PyLong_FromUnsignedLongLong($1_name);";
%typemap(directorin, parse="l") int *DIRECTORIN, long* DIRECTORIN, %typemap(directorin, parse="l") bool *DIRECTORIN,
unsigned int *DIRECTORIN, unsigned long *DIRECTORIN, signed char *DIRECTORIN,
short *DIRECTORIN, unsigned short *DIRECTORIN, unsigned char *DIRECTORIN,
char *DIRECTORIN, unsigned char *DIRECTORIN short *DIRECTORIN,
"(long) *$1_name"; unsigned short *DIRECTORIN,
%typemap(directorin, parse="f") float *DIRECTORIN "*$1_name"; int *DIRECTORIN,
%typemap(directorin, parse="d") double *DIRECTORIN "*$1_name"; long *DIRECTORIN "(long) *$1_name";
%typemap(directorin, parse="O") PyObject* ""; %typemap(directorin) unsigned int *DIRECTORIN,
unsigned long *DIRECTORIN
"$input = SPyObj_FromUnsignedLong((unsigned long) *$1_name);";
%typemap(directorin, parse="l") std::size_t, const std::size_t& "(long) $input"; %typemap(directorin,parse="f") float *DIRECTORIN "*$1_name";
%typemap(directorin,parse="d") double *DIRECTORIN "*$1_name";
%typemap(directorin,parse="c") char *DIRECTORIN "*$1_name";
%typemap(directorin,parse="s") char **DIRECTORIN "*$1_name";
%typemap(directorin,parse="O") PyObject* "";
/* // this is rather dangerous /* // this is rather dangerous
%typemap(directorin) SWIGTYPE { %typemap(directorin) SWIGTYPE {
@ -516,30 +501,32 @@
%define DIRECTOROUT_TYPEMAP(type, converter) %define DIRECTOROUT_TYPEMAP(type, converter)
%typemap(directorargout) type *DIRECTOROUT %typemap(directorargout) type *DIRECTOROUT
"*$result = (type) converter($input); "*$result = ($ltype) converter($input);
if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using converter\");"; if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using converter\");";
%typemap(directorout) type %typemap(directorout) type
"$result = (type) converter($input); "$result = ($ltype) converter($input);
if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using converter\");"; if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using converter\");";
%typemap(directorout) type &DIRECTOROUT = type %typemap(directorout) type &DIRECTOROUT = type
%enddef %enddef
DIRECTOROUT_TYPEMAP(char, PyInt_AsLong); DIRECTOROUT_TYPEMAP(signed char, SPyObj_AsSignedChar);
DIRECTOROUT_TYPEMAP(unsigned char, PyInt_AsLong); DIRECTOROUT_TYPEMAP(short, SPyObj_AsShort);
DIRECTOROUT_TYPEMAP(short, PyInt_AsLong); DIRECTOROUT_TYPEMAP(int, SPyObj_AsInt);
DIRECTOROUT_TYPEMAP(unsigned short, PyInt_AsLong); DIRECTOROUT_TYPEMAP(long, SPyObj_AsLong);
DIRECTOROUT_TYPEMAP(int, PyInt_AsLong); DIRECTOROUT_TYPEMAP(long long, SPyObj_AsLongLong);
DIRECTOROUT_TYPEMAP(unsigned int, PyInt_AsLong);
DIRECTOROUT_TYPEMAP(long, PyInt_AsLong); DIRECTOROUT_TYPEMAP(unsigned char, SPyObj_AsUnsignedChar);
DIRECTOROUT_TYPEMAP(unsigned long, PyInt_AsLong); DIRECTOROUT_TYPEMAP(unsigned short, SPyObj_AsUnsignedShort);
DIRECTOROUT_TYPEMAP(long long, PyLong_AsLongLong); DIRECTOROUT_TYPEMAP(unsigned int, SPyObj_AsUnsignedInt);
DIRECTOROUT_TYPEMAP(unsigned long long, PyLong_AsUnsignedLongLong); DIRECTOROUT_TYPEMAP(unsigned long, SPyObj_AsUnsignedLong);
DIRECTOROUT_TYPEMAP(float, PyFloat_AsDouble); DIRECTOROUT_TYPEMAP(unsigned long long, SPyObj_AsUnsignedLongLong);
DIRECTOROUT_TYPEMAP(double, PyFloat_AsDouble);
DIRECTOROUT_TYPEMAP(bool, PyInt_AsLong); DIRECTOROUT_TYPEMAP(float, SPyObj_AsFloat);
DIRECTOROUT_TYPEMAP(PyObject *, ); DIRECTOROUT_TYPEMAP(double, SPyObj_AsDouble);
DIRECTOROUT_TYPEMAP(bool, SPyObj_AsBool);
DIRECTOROUT_TYPEMAP(char, SPyObj_AsChar);
DIRECTOROUT_TYPEMAP(char *, PyString_AsString); DIRECTOROUT_TYPEMAP(char *, PyString_AsString);
DIRECTOROUT_TYPEMAP(std::size_t, PyInt_AsLong); DIRECTOROUT_TYPEMAP(PyObject *, );
/* Object returned by value. Convert from a pointer */ /* Object returned by value. Convert from a pointer */
%typemap(directorout) SWIGTYPE ($&ltype argp) %typemap(directorout) SWIGTYPE ($&ltype argp)
@ -569,17 +556,25 @@ DIRECTOROUT_TYPEMAP(std::size_t, PyInt_AsLong);
$2 = ($2_ltype) PyString_Size($input); $2 = ($2_ltype) PyString_Size($input);
} }
/* ------------------------------------------------------------
* Enums
* ------------------------------------------------------------ */
%apply int { enum SWIGTYPE };
%apply const int& { const enum SWIGTYPE& };
/* ------------------------------------------------------------ /* ------------------------------------------------------------
* ANSI C typemaps * ANSI C typemaps
* ------------------------------------------------------------ */ * ------------------------------------------------------------ */
%typemap(in) size_t "$1 = (size_t) PyInt_AsLong($input); %apply unsigned long { size_t };
if (PyErr_Occurred()) SWIG_fail;"; %apply const unsigned long& { const size_t& };
%typemap(out) size_t = long;
%typemap(varin) size_t = long; #ifdef __cplusplus
%typemap(varout) size_t = long; %apply unsigned long { std::size_t };
%typemap(consttab) size_t = long; %apply const unsigned long& { const std::size_t& };
#endif
/* ------------------------------------------------------------ /* ------------------------------------------------------------
* PyObject * - Just pass straight through unmodified * PyObject * - Just pass straight through unmodified
@ -591,32 +586,43 @@ DIRECTOROUT_TYPEMAP(std::size_t, PyInt_AsLong);
/* ------------------------------------------------------------ /* ------------------------------------------------------------
* Typechecking rules * Typechecking rules
* ------------------------------------------------------------ */ * ------------------------------------------------------------ */
%define %typecheck_pyfunc(check, type, pyfunc)
%typecheck(SWIG_TYPECHECK_##check) type, const type&
{
pyfunc($input);
if (PyErr_Occurred()) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
%enddef
%typecheck(SWIG_TYPECHECK_INTEGER) %typecheck_pyfunc(BOOL, bool, SPyObj_AsBool);
int, short, long, %typecheck_pyfunc(INT8, signed char, SPyObj_AsSignedChar);
unsigned int, unsigned short, unsigned long, %typecheck_pyfunc(UINT8, unsigned char, SPyObj_AsUnsignedChar);
signed char, unsigned char, %typecheck_pyfunc(INT16, short, SPyObj_AsShort);
long long, unsigned long long, %typecheck_pyfunc(UINT16, unsigned short, SPyObj_AsUnsignedShort);
const int &, const short &, const long &, %typecheck_pyfunc(INT32, int, SPyObj_AsInt);
const unsigned int &, const unsigned short &, const unsigned long &, %typecheck_pyfunc(UINT32, unsigned int, SPyObj_AsUnsignedInt);
const long long &, const unsigned long long &, %typecheck_pyfunc(INTEGER, unsigned long, SPyObj_AsUnsginedLong);
enum SWIGTYPE, %typecheck_pyfunc(INTEGER, unsigned long long, SPyObj_AsUnsignedLongLong);
bool, const bool & %typecheck_pyfunc(CHAR, char, SPyObj_AsChar);
%typecheck_pyfunc(FLOAT, float, SPyObj_AsFloat);
%typecheck(SWIG_TYPECHECK_INTEGER)
long, const long &,
long long, const long long &
{ {
$1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0; $1 = (PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
} }
%typecheck(SWIG_TYPECHECK_DOUBLE) %typecheck(SWIG_TYPECHECK_DOUBLE) double, const double &
float, double,
const float &, const double &
{ {
$1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0; $1 = (PyFloat_Check($input) || PyInt_Check($input) || PyLong_Check($input)) ? 1 : 0;
} }
%typecheck(SWIG_TYPECHECK_CHAR) char {
$1 = (PyString_Check($input) && (PyString_Size($input) == 1)) ? 1 : 0;
}
%typecheck(SWIG_TYPECHECK_STRING) char * { %typecheck(SWIG_TYPECHECK_STRING) char * {
$1 = PyString_Check($input) ? 1 : 0; $1 = PyString_Check($input) ? 1 : 0;
} }
@ -660,28 +666,34 @@ DIRECTOROUT_TYPEMAP(std::size_t, PyInt_AsLong);
* Exception handling * Exception handling
* ------------------------------------------------------------ */ * ------------------------------------------------------------ */
%typemap(throws) int, %typemap(throws) bool,
long, signed char,
short, unsigned short,
unsigned int, short,
unsigned long, unsigned char,
unsigned short { int,
PyErr_SetObject(PyExc_RuntimeError, PyInt_FromLong((long) $1)); long {
PyErr_SetObject(PyExc_RuntimeError, PyInt_FromLong($1));
SWIG_fail; SWIG_fail;
} }
%typemap(throws) SWIGTYPE CLASS { %typemap(throws) unsigned int, unsigned long {
$&1_ltype temp = new $1_ltype($1); PyErr_SetObject(PyExc_RuntimeError, SPyObj_FromUnsignedLong($1));
if ($&1_descriptor->clientdata) {
PyErr_SetObject((PyObject *) ($&1_descriptor->clientdata), SWIG_NewPointerObj(temp,$&1_descriptor,1));
} else {
PyErr_SetObject(PyExc_RuntimeError, SWIG_NewPointerObj(temp,$&1_descriptor,1));
}
SWIG_fail; SWIG_fail;
} }
%typemap(throws) SWIGTYPE { %typemap(throws) long long {
PyErr_SetString(PyExc_RuntimeError,"$1_type"); PyErr_SetObject(PyExc_RuntimeError, SPyObj_FromLongLong($1));
SWIG_fail;
}
%typemap(throws) unsigned long long {
PyErr_SetObject(PyExc_RuntimeError, SPyObj_FromUnsignedLongLong($1));
SWIG_fail;
}
%typemap(throws) char {
PyErr_SetObject(PyExc_RuntimeError, SPyObj_FromChar($1));
SWIG_fail; SWIG_fail;
} }
@ -690,6 +702,29 @@ DIRECTOROUT_TYPEMAP(std::size_t, PyInt_AsLong);
SWIG_fail; SWIG_fail;
} }
%typemap(throws) float, double {
PyErr_SetObject(PyExc_RuntimeError, PyFloat_FromDouble($1));
SWIG_fail;
}
%typemap(throws) SWIGTYPE {
$&1_ltype temp = new $1_ltype($1);
if ($&1_descriptor->clientdata) {
PyErr_SetObject((PyObject *) ($&1_descriptor->clientdata), SWIG_NewPointerObj(temp,$&1_descriptor,1));
} else {
PyErr_SetString(PyExc_RuntimeError,"$1_type");
//PyErr_SetObject(PyExc_RuntimeError, SWIG_NewPointerObj(temp,$&1_descriptor,1));
}
SWIG_fail;
}
/*
%typemap(throws) SWIGTYPE {
PyErr_SetString(PyExc_RuntimeError,"$1_type");
SWIG_fail;
}
*/
/* ------------------------------------------------------------ /* ------------------------------------------------------------
* Overloaded operator support * Overloaded operator support
* ------------------------------------------------------------ */ * ------------------------------------------------------------ */