jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
swig/Lib/python/python.swg
Marcelo Matus 3f1f31d1e8 Fix long long and other warnings. 
Add the macros

%typemap_asfromcheck()
%typemap_asfrom()

that can be used to defined all the different typemaps
for types where the As/From/Check methods are provided.

All the basic type (int, char,...) typemaps are implemented
using them.

The std::string and std::complex<T> are reimplemented using
the new %typemap_asfrom/check macros too. This helps to complete
all the previously missing typemaps (consttab, varin, varout,..)
and also ilustrates how to define the As/From/Check methods
to use with the %typemap_asfrom/check macros.

As a byproduct, the C complex typemap was added, and the file

complex.i

can be used to load the complex support for either C or C++. The
original C++ std_complex.i is still there, and the corresponding C
ccomplex.i too, if they need to be included explicitly.

Also, the As/From methods are declared via %fragment, so, they
can be reused as needed, and only appear in the wrapped code if
they corresponding typemap is invoked, making the typemaps
and the entire code shorter and simpler.


Marcelo.


git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@5691 626c5289-ae23-0410-ae9c-e8d60b6d4f22
2004-01-28 01:30:13 +00:00

790 lines
26 KiB
Text
Raw Blame History

/* -----------------------------------------------------------------------------
* python.swg
*
* Python configuration module.
* ----------------------------------------------------------------------------- */
/* Python.h has to appear first */
%insert(runtime) %{
#include "Python.h"
%}
%insert(runtime) "precommon.swg";
%insert(runtime) "common.swg"; // Common type-checking code
%insert(runtime) "pyrun.swg"; // Python run-time code
/* Special directive for shadow code */
#define %shadow %insert("shadow")
#define %pythoncode %insert("python")
/* auxiliar memory allocators */
#ifdef __cplusplus
#define %swig_new(type, size) new type[(size)]
#define %swig_delete(cptr) delete [] cptr;
#else
#define %swig_new(type, size) (type*) malloc((size)*sizeof(type))
#define %swig_delete(cptr) free((char*)cptr);
#endif
/* -----------------------------------------------------------------------------
* standard typemaps
* ----------------------------------------------------------------------------- */
/* -----------------------------------------------------------------------------
* --- memberin and globalin typemaps ---
* ----------------------------------------------------------------------------- */
/* Character array handling */
%typemap(memberin) char [ANY] {
if ($input) memcpy($1,$input,$1_dim0);
else memset($1,0,$1_dim0);
}
%typemap(globalin) char [ANY] {
if ($input) memcpy($1,$input,$1_dim0);
else memset($1,0,$1_dim0);
}
/* -----------------------------------------------------------------------------
* --- Input arguments ---
* ----------------------------------------------------------------------------- */
/* Primitive datatypes. */
%define PY_IN_TYPEMAP(type, pyobj_as)
%typemap(in,fragment=#pyobj_as) type {
$1 = ($1_type) pyobj_as($input);
if (PyErr_Occurred()) SWIG_fail;
}
%typemap(in) const type& ($basetype temp) {
temp = ($basetype) pyobj_as($input);
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;
}
%enddef
/* Pointers, references, and arrays */
%typemap(in) SWIGTYPE *,
SWIGTYPE []
"if ((SWIG_ConvertPtr($input,(void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION | $disown )) == -1) SWIG_fail;"
%typemap(in) SWIGTYPE *DISOWN
"if ((SWIG_ConvertPtr($input,(void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN )) == -1) SWIG_fail;"
/* Additional check for null references */
%typemap(in) SWIGTYPE &
"if ((SWIG_ConvertPtr($input,(void **) &$1, $1_descriptor,SWIG_POINTER_EXCEPTION | $disown )) == -1) SWIG_fail;
if ($1 == NULL) { PyErr_SetString(PyExc_TypeError,\"null reference\"); SWIG_fail; }"
/* Void pointer. Accepts any kind of pointer */
%typemap(in) void * "if ((SWIG_ConvertPtr($input,(void **) &$1, 0, SWIG_POINTER_EXCEPTION | $disown )) == -1) SWIG_fail;"
/* Object passed by value. Convert to a pointer */
%typemap(in) SWIGTYPE ($&1_ltype argp) "if ((SWIG_ConvertPtr($input,(void **) &argp, $&1_descriptor,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
$1 = *argp; ";
/* Pointer to a class member */
%typemap(in) SWIGTYPE (CLASS::*) "if ((SWIG_ConvertPacked($input, (void *) &$1, sizeof($1_type), $1_descriptor,SWIG_POINTER_EXCEPTION)) == -1) SWIG_fail;";
/* The char* and char [ANY] case */
%typemap(in) char *, char const*, char *const, char const *const
{
$1 = SWIG_PyObj_AsCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) SWIG_fail;
}
%typemap(in) char const*&, char *const&, char const *const &
{
$*ltype temp = SWIG_PyObj_AsCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) SWIG_fail;
$1 = &temp;
}
%typemap(in) char [ANY], const char [ANY]
{
char temp[$1_dim0];
SWIG_PyObj_AsCharArray($input, $descriptor(char*), temp, $1_dim0);
if (PyErr_Occurred()) SWIG_fail;
$1 = temp;
}
/* -----------------------------------------------------------------------------
* --- Outnput arguments ---
* ----------------------------------------------------------------------------- */
/* Primitive types */
%define PY_OUT_TYPEMAP(type, pyobj_from)
%typemap(out,fragment=#pyobj_from) type "$result = pyobj_from((type)$1);";
%typemap(out,fragment=#pyobj_from) const type& "$result = pyobj_from((type) *($1));";
%enddef
/* Pointers, references, and arrays */
%typemap(out) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] "$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, $owner);";
/* Dynamic casts */
%typemap(out) SWIGTYPE *DYNAMIC, SWIGTYPE &DYNAMIC {
swig_type_info *ty = SWIG_TypeDynamicCast($1_descriptor, (void **) &$1);
$result = SWIG_NewPointerObj((void *) $1, ty, $owner);
}
/* Member pointer */
%typemap(out) SWIGTYPE (CLASS::*) "$result = SWIG_NewPackedObj((void *) &$1, sizeof($1_type), $1_descriptor);";
/* Void */
%typemap(out) void "Py_INCREF(Py_None); $result = Py_None;";
/* Special typemap for character array return values */
%typemap(out) char*, char const*, char *const, char const *const,
char *const &, char const* &, char const *const &
"$result = SWIG_PyObj_FromCharPtr((const char*)$1);";
%typemap(out) char [ANY], const char [ANY]
"$result = SWIG_PyObj_FromCharArray((const char*)$1, $1_dim0);";
/* Primitive types--return by value */
%typemap(out) SWIGTYPE
#ifdef __cplusplus
{
$&1_ltype resultptr;
resultptr = new $1_ltype(($1_ltype &) $1);
$result = SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1);
}
#else
{
$&1_ltype resultptr;
resultptr = ($&1_ltype) malloc(sizeof($1_type));
memmove(resultptr, &$1, sizeof($1_type));
$result = SWIG_NewPointerObj((void *) resultptr, $&1_descriptor, 1);
}
#endif
/* -----------------------------------------------------------------------------
* --- Variable input ---
* ----------------------------------------------------------------------------- */
/* primitive types */
%define PY_VARIN_TYPEMAP(type, pyobj_as)
%typemap(varin,fragment=#pyobj_as) type {
$1_type temp = ($1_type) pyobj_as($input);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = temp;
}
%enddef
/* char* and char[ANY] */
%typemap(varin) char * {
char *cptr = SWIG_PyObj_AsNewCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
if ($1) %swig_delete($1);
$1 = cptr;
}
%typemap(varin,warning="451:Setting const char * variable may leak memory") const char * {
char *cptr = SWIG_PyObj_AsNewCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = cptr;
}
%typemap(varin) char [ANY] {
SWIG_PyObj_AsCharArray($input, $descriptor(char*), $1, $1_dim0);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
}
/* Pointers, references, and arrays */
%typemap(varin) SWIGTYPE [ANY] {
void *temp;
int ii;
$1_basetype *b = 0;
if ((SWIG_ConvertPtr($input,(void **) &temp, $1_descriptor, SWIG_POINTER_EXCEPTION)) == -1) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
b = ($1_basetype *) $1;
for (ii = 0; ii < $1_size; ii++) b[ii] = *(($1_basetype *) temp + ii);
}
%typemap(varin) SWIGTYPE * {
void *temp;
if ((SWIG_ConvertPtr($input,(void **) &temp, $1_descriptor, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN)) == -1) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = ($1_ltype) temp;
}
%typemap(varin) SWIGTYPE & {
void *temp;
if ((SWIG_ConvertPtr($input,(void **) &temp, $1_descriptor, SWIG_POINTER_EXCEPTION)) == -1 || temp == NULL) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = *($1_ltype) temp;
}
%typemap(varin) void * {
void * temp;
if ((SWIG_ConvertPtr($input,(void **) &temp, 0, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN)) == -1) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = ($1_ltype) temp;
}
%typemap(varin) SWIGTYPE (CLASS::*) {
char temp[sizeof($1_type)];
if ((SWIG_ConvertPacked($input,(void *) temp, sizeof($1_type), $1_descriptor, SWIG_POINTER_EXCEPTION)) == -1) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
memmove((void *) &$1,temp,sizeof($1_type));
}
%typemap(varin) SWIGTYPE {
$&1_ltype temp;
if ((SWIG_ConvertPtr($input, (void **) &temp, $&1_descriptor, SWIG_POINTER_EXCEPTION)) == -1) {
PyErr_SetString(PyExc_TypeError, "C variable '$name ($1_ltype)'");
return 1;
}
$1 = *(($&1_type) temp);
}
/* -----------------------------------------------------------------------------
* --- Variable output ---
* ----------------------------------------------------------------------------- */
/* Primitive types */
%define PY_VAROUT_TYPEMAP(type, pyobj_from)
%typemap(varout,fragment=#pyobj_from) type, const type& "$result = pyobj_from((type)$1);";
%enddef
/* Pointers and arrays */
%typemap(varout) SWIGTYPE *, SWIGTYPE []
"$result = SWIG_NewPointerObj((void *) $1, $1_descriptor, 0);";
/* References */
%typemap(varout) SWIGTYPE &
"$result = SWIG_NewPointerObj((void *) &$1, $1_descriptor, 0);";
/* Member pointer */
%typemap(varout) SWIGTYPE (CLASS::*)
"$result = SWIG_NewPackedObj((void *) &$1, sizeof($1_type), $1_descriptor);";
/* Void */
%typemap(varout) void "Py_INCREF(Py_None); $result = Py_None;";
/* Special typemap for char* return values */
%typemap(varout) char*, char const*, char *const, char const *const
"$result = SWIG_PyObj_FromCharPtr($1);";
/* Special typemap for character array return values */
%typemap(varout) char [ANY], const char [ANY]
"$result = SWIG_PyObj_FromCharArray($1, $1_dim0);";
%typemap(varout) SWIGTYPE
"$result = SWIG_NewPointerObj((void *) &$1, $&1_descriptor, 0);";
/* -----------------------------------------------------------------------------
* --- Constants --- *
* ----------------------------------------------------------------------------- */
/* Primitive types */
%define PY_CONSTCODE_TYPEMAP(type, pyobj_from)
%typemap(constcode,fragment=#pyobj_from) type
"PyDict_SetItemString(d,\"$symname\", pyobj_from((type)$value));";
%enddef
/* Pointers, arrays, objects */
%typemap(consttab) char *, char const*, char * const, char const* const
{ SWIG_PY_STRING, (char*)"$symname", 0, 0, (void *)$value, 0}
%typemap(consttab) char [ANY], const char [ANY]
"PyDict_SetItemString(d,\"$symname\", SWIG_PyObj_FromCharArray($value, $value_dim0));";
%typemap(consttab) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
{ SWIG_PY_POINTER, (char*)"$symname", 0, 0, (void *)$value, &$1_descriptor}
%typemap(consttab) SWIGTYPE (CLASS::*)
{ SWIG_PY_BINARY, (char *)"$symname", sizeof($type), 0, (void *)&$value, &$1_descriptor}
/* -----------------------------------------------------------------------------
* --- Director typemaps --- *
* ----------------------------------------------------------------------------- */
/*
*
* Inverse argument typemaps are for marshaling C/C++ parameters to call Python
* methods from C++ proxy wrapper classes.
*
*/
/* --- directorin typemaps --- */
/* Primitive datatypes */
%define PY_DIRECTORIN_TYPEMAP(type, pyobj_from)
%typemap(directorin,fragment=#pyobj_from) type *DIRECTORIN "$input = pyobj_from((type) *$1_name);";
%typemap(directorin,fragment=#pyobj_from) type, const type& "$input = pyobj_from((type) $1_name);";
%enddef
/* we just pass the char* as a pointer, much cheaper */
%typemap(directorin) char *, char const*, char *const, char const *const,
char const *&, char *const &, char const *const &
"$input = SWIG_NewPointerObj((void *) $1_name, $descriptor(char*), $owner);"
/* "$input = SWIG_PyObj_FromCharPtr((const char*)$1_name);"; */
/* here we need to create a python object, or we lost the 'ANY' dimension */
%typemap(directorin) char [ANY], const char [ANY]
"$input = SWIG_PyObj_FromCharArray((const char*)$1_name, $1_dim0);";
/* --- directorout typemaps --- */
%define PY_DIRECTOROUT_TYPEMAP(Type, pyobj_as)
%typemap(directorargout,fragment=#pyobj_as) Type *DIRECTOROUT
"*$result = ($basetype) pyobj_as($input);
if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using pyobj_as\");";
%typemap(directorout,fragment=#pyobj_as) Type
"$result = ($basetype) pyobj_as($input);
if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using pyobj_as\");";
%typemap(directorout,fragment=#pyobj_as) const Type&
"$basetype temp = ($basetype) pyobj_as($input);
$result = &temp;
if (PyErr_Occurred()) throw Swig::DirectorTypeMismatchException(\"Error converting Python object using pyobj_as\");";
%typemap(directorout,fragment=#pyobj_as) Type &DIRECTOROUT = Type
%enddef
/* Char pointer and arrays */
%typemap(directorout) char *, char const*, char *const, char const* const {
$result = SWIG_PyObj_AsCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) {
Swig::DirectorTypeMismatchException("Error converting Python object into char*");
}
}
%typemap(directorout) char const *&, char *const &, char const *const & {
char* temp = SWIG_PyObj_AsCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) {
Swig::DirectorTypeMismatchException("Error converting Python object into char*");
}
$result = ($1_ltype) &temp;
}
%typemap(directorout) char [ANY], const char[ANY] (char temp[$result_dim0]) {
SWIG_PyObj_AsCharArray($input, $descriptor(char*), temp, $result_dim0);
if (PyErr_Occurred()) {
Swig::DirectorTypeMismatchException("Error converting Python object into char[$result_dim0]");
}
$result = temp;
}
/* Object returned by value. Convert from a pointer */
%typemap(directorout) SWIGTYPE ($&ltype argp)
"if ((SWIG_ConvertPtr($input,(void **) &argp, $&descriptor,SWIG_POINTER_EXCEPTION | $disown )) == -1) throw Swig::DirectorTypeMismatchException(\"Pointer conversion failed.\"); $result = *argp;";
%typemap(directorout) SWIGTYPE *,
SWIGTYPE &,
SWIGTYPE []
"if ((SWIG_ConvertPtr($input,(void **) &$result, $descriptor,SWIG_POINTER_EXCEPTION | $disown )) == -1) throw Swig::DirectorTypeMismatchException(\"Pointer conversion failed.\");";
%typemap(directorout) void * "if ((SWIG_ConvertPtr($input,(void **) &$result, 0, SWIG_POINTER_EXCEPTION | $disown )) == -1) throw Swig::DirectorTypeMismatchException(\"Pointer conversion failed.\");";
/* ------------------------------------------------------------
* --- Typechecking rules ---
* ------------------------------------------------------------ */
%define PY_TYPECHECK_TYPEMAP(check, type, pyobj_asorcheck)
%typemap(typecheck,fragment=#pyobj_asorcheck,precedence=SWIG_TYPECHECK_##check) type, const type&
{
pyobj_asorcheck($input);
if (PyErr_Occurred()) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
%enddef
%typecheck(SWIG_TYPECHECK_STRING)
char *, char const*, char *const, char const *const,
char const*&, char *const&, char const *const &
{
SWIG_PyObj_AsCharPtr($input, $descriptor(char*));
if (PyErr_Occurred()) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
%typecheck(SWIG_TYPECHECK_CHAR_ARRAY) char [ANY], const char[ANY]
{
char* carray = 0; size_t size = 0;
SWIG_PyObj_AsCharArray($input, $descriptor(char*), &carray, &size);
if (PyErr_Occurred()) {
$1 = 0;
PyErr_Clear();
} else {
$1 = ((carray != 0) && (size <= $input_dim0));
}
}
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE *, SWIGTYPE &, SWIGTYPE []
{
void *ptr;
if (SWIG_ConvertPtr($input, (void **) &ptr, $1_descriptor, 0) == -1) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
%typecheck(SWIG_TYPECHECK_POINTER) SWIGTYPE
{
void *ptr;
if (SWIG_ConvertPtr($input, (void **) &ptr, $&1_descriptor, 0) == -1) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
%typecheck(SWIG_TYPECHECK_VOIDPTR) void *
{
void *ptr;
if (SWIG_ConvertPtr($input, (void **) &ptr, 0, 0) == -1) {
$1 = 0;
PyErr_Clear();
} else {
$1 = 1;
}
}
/* ------------------------------------------------------------
* --- Exception handling ---
* ------------------------------------------------------------ */
%define PY_THROWS_TYPEMAP(type, pyobj_from)
%typemap(throws,fragment=#pyobj_from) type {
PyErr_SetObject(PyExc_RuntimeError, pyobj_from((type)$1));
SWIG_fail;
}
%enddef
%typemap(throws) char *, char const*, char * const, char const* const {
PyErr_SetObject(PyExc_RuntimeError, SWIG_PyObj_FromCharPtr((const char*)$1));
SWIG_fail;
}
%typemap(throws) char[ANY], const char[ANY] {
PyErr_SetObject(PyExc_RuntimeError, SWIG_PyObj_FromCharArray((const char*)$1, $1_dim0));
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;
}
// This doesn't work, and not sure if it is needed...
#if 0
%typecheck(throws) SWIGTYPE *, SWIGTYPE &, SWIGTYPE [] {
if ($1_descriptor->clientdata) {
PyErr_SetObject((PyObject *) ($1_descriptor->clientdata), SWIG_NewPointerObj($1,$1_descriptor,1));
} else {
PyErr_SetString(PyExc_RuntimeError,"$1_type");
}
SWIG_fail;
}
#endif
/* ------------------------------------------------------------
* PyObject * - Just pass straight through unmodified
* ------------------------------------------------------------ */
%typemap(in) PyObject * "$1 = $input;";
%typemap(out) PyObject * "$result = $1;";
%typemap(constcode) PyObject * "PyDict_SetItemString(d,\"$symname\", $value);";
%typemap(directorin, parse="O") PyObject * "";
%typemap(directorout) PyObject * "$result = $input;";
%typecheck(SWIG_TYPECHECK_POINTER) PyObject * "$1 = ($input != 0);";
%typemap(throws) PyObject * {
PyErr_SetObject(PyExc_RuntimeError, $1);
SWIG_fail;
}
/* ------------------------------------------------------------
* Basic as/from type specialization
* ------------------------------------------------------------ */
/*
typemap definition for types with As/From/Check methods
*/
%define %typemap_asfromcheck(Type, CheckCode, AsType, FromType, CheckType)
PY_IN_TYPEMAP(Type, AsType);
PY_OUT_TYPEMAP(Type, FromType);
PY_VARIN_TYPEMAP(Type, AsType);
PY_VAROUT_TYPEMAP(Type, FromType);
PY_CONSTCODE_TYPEMAP(Type, FromType);
PY_DIRECTORIN_TYPEMAP(Type, FromType);
PY_DIRECTOROUT_TYPEMAP(Type, AsType);
PY_THROWS_TYPEMAP(Type, FromType);
PY_TYPECHECK_TYPEMAP(CheckCode, Type, CheckType);
%enddef
/*
typemap definition for types with As/From methods. The cheking is
performed by calling the As method.
*/
%define %typemap_asfrom(Type, CheckCode, AsType, FromType)
PY_IN_TYPEMAP(Type, AsType);
PY_OUT_TYPEMAP(Type, FromType);
PY_VARIN_TYPEMAP(Type, AsType);
PY_VAROUT_TYPEMAP(Type, FromType);
PY_CONSTCODE_TYPEMAP(Type, FromType);
PY_DIRECTORIN_TYPEMAP(Type, FromType);
PY_DIRECTOROUT_TYPEMAP(Type, AsType);
PY_THROWS_TYPEMAP(Type, FromType);
PY_TYPECHECK_TYPEMAP(CheckCode, Type, AsType);
%enddef
/*
typemap for simple types with conversor methods
named as SWIG_PyObj_As##Name/SWIG_PyObj_From##Name
*/
%define %typemap_stype(Type, CheckCode, Name)
%typemap_asfrom(Type, CheckCode, SWIG_PyObj_As##Name,SWIG_PyObj_From##Name)
%enddef
/* ------------------------------------------------------------
* Primitive Types
* ------------------------------------------------------------ */
%include "pyprim.swg"
%typemap_stype(bool, BOOL, Bool);
%typemap_stype(signed char, INT8, SignedChar);
%typemap_stype(unsigned char, UINT8, UnsignedChar);
%typemap_stype(short, INT16, Short);
%typemap_stype(unsigned short, UINT16, UnsignedShort);
%typemap_stype(int, INT32, Int);
%typemap_stype(unsigned int, UINT32, UnsignedInt);
%typemap_stype(long, INT64, Long);
%typemap_stype(unsigned long, UINT64, UnsignedLong);
%typemap_stype(long long, INT128, LongLong);
%typemap_stype(unsigned long long, UINT128, UnsignedLongLong);
%typemap_stype(float, FLOAT, Float);
%typemap_stype(double, DOUBLE, Double);
%typemap_stype(char, CHAR, Char);
/* ------------------------------------------------------------
* --- Enums ---
* ------------------------------------------------------------ */
%apply int { enum SWIGTYPE };
// this doesn't work very well, you need to redefined it for each enum.
%apply const int& { const enum SWIGTYPE& };
/* ------------------------------------------------------------
* --- ANSI/Posix C typemaps ---
* ------------------------------------------------------------ */
%apply unsigned long { size_t };
%apply const unsigned long& { const size_t& };
%apply long { ptrdiff_t };
%apply const long& { const ptrdiff_t& };
#ifdef __cplusplus
%apply unsigned long { std::size_t };
%apply const unsigned long& { const std::size_t& };
%apply long { std::ptrdiff_t };
%apply const long& { const std::ptrdiff_t& };
#endif
/* ------------------------------------------------------------
* --- String & length ---
* ------------------------------------------------------------ */
/* Here len doesn't include the '0' terminator */
%typemap(in) (char *STRING, int LENGTH) (char *buf, size_t size) {
SWIG_PyObj_AsCharPtrAndSize($input, $descriptor(char*), &buf, &size);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,"a string is expected");
SWIG_fail;
}
$1 = ($1_ltype) buf;
$2 = ($2_ltype) (size && (buf[size -1] == 0)) ? size - 1 : size;
}
/* Here size includes the '0' terminator */
%typemap(in) (char *STRING, int SIZE) (char *buf, size_t size) {
SWIG_PyObj_AsCharPtrAndSize($input, $descriptor(char*), &buf, &size);
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,"a string is expected");
SWIG_fail;
}
$1 = ($1_ltype) buf;
$2 = ($2_ltype) size;
}
/* ------------------------------------------------------------
* --- Argc & Argv ---
* ------------------------------------------------------------ */
/* This typemap works with either a list or a tuple */
%typemap(in) (int ARGC, char **ARGV) {
/* Check if is a list */
int list = PyList_Check($input);
if (list || PyTuple_Check($input)) {
int argc = list ? PyList_Size($input) : PyTuple_Size($input);
char **argv = %swig_new(char*, argc + 1);
int i = 0;
for (; i < argc; ++i) {
PyObject *obj = list ? PyList_GetItem($input,i) : PyTuple_GetItem($input,i);
argv[i] = SWIG_PyObj_AsCharPtr(obj, $descriptor(char*));
if (PyErr_Occurred()) {
PyErr_SetString(PyExc_TypeError,"list or tuple must contain strings only");
SWIG_fail;
}
}
argv[i] = 0;
$1 = ($1_ltype) argc;
$2 = ($2_ltype) argv;
} else {
$1 = 0;
$2 = 0;
PyErr_SetString(PyExc_TypeError,"a list or tuple is expected");
SWIG_fail;
}
}
%typemap(freearg) (int ARGC, char **ARGV) {
if ($2) %swig_delete($2);
}
/*****************************************************************************
*
* End of C++ proxy wrapper typemaps.
*
*****************************************************************************/
/* ------------------------------------------------------------
* Overloaded operator support
* ------------------------------------------------------------ */
#ifdef __cplusplus
%rename(__add__) *::operator+;
%rename(__pos__) *::operator+();
%rename(__pos__) *::operator+() const;
%rename(__sub__) *::operator-;
%rename(__neg__) *::operator-();
%rename(__neg__) *::operator-() const;
%rename(__mul__) *::operator*;
%rename(__div__) *::operator/;
%rename(__mod__) *::operator%;
%rename(__lshift__) *::operator<<;
%rename(__rshift__) *::operator>>;
%rename(__and__) *::operator&;
%rename(__or__) *::operator|;
%rename(__xor__) *::operator^;
%rename(__invert__) *::operator~;
%rename(__iadd__) *::operator+=;
%rename(__isub__) *::operator-=;
%rename(__imul__) *::operator*=;
%rename(__idiv__) *::operator/=;
%rename(__imod__) *::operator%=;
%rename(__ilshift__) *::operator<<=;
%rename(__irshift__) *::operator>>=;
%rename(__iand__) *::operator&=;
%rename(__ior__) *::operator|=;
%rename(__ixor__) *::operator^=;
%rename(__lt__) *::operator<;
%rename(__le__) *::operator<=;
%rename(__gt__) *::operator>;
%rename(__ge__) *::operator>=;
%rename(__eq__) *::operator==;
%rename(__ne__) *::operator!=;
/* Special cases */
%rename(__call__) *::operator();
/* Ignored operators */
%ignorewarn("362:operator= ignored") operator=;
%ignorewarn("383:operator++ ignored") operator++;
%ignorewarn("384:operator-- ignored") operator--;
%ignorewarn("361:operator! ignored") operator!;
%ignorewarn("381:operator&& ignored") operator&&;
%ignorewarn("382:operator|| ignored") operator||;
%ignorewarn("386:operator->* ignored") operator->*;
%ignorewarn("389:operator[] ignored (consider using %extend)") operator[];
#endif
/* Warnings for Python keywords */
%include "pythonkw.swg"
/* The start of the Python initialization function */
%init %{
#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT(void) SWIG_init(void) {
static PyObject *SWIG_globals = 0;
static int typeinit = 0;
PyObject *m, *d;
int i;
if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
m = Py_InitModule((char *) SWIG_name, SwigMethods);
d = PyModule_GetDict(m);
if (!typeinit) {
for (i = 0; swig_types_initial[i]; i++) {
swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
}
typeinit = 1;
}
SWIG_InstallConstants(d,swig_const_table);
%}
Reference in a new issue View git blame Copy permalink