jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Stopped using template class SwigPyBuiltin, because it caused problems

Browse source 
when two typedef-equivalent types are wrapped as separate classes.

Now failing on refcount.cpptest.



git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/branches/szager-python-builtin@12392 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Stefan Zager 2011-01-12 00:43:01 +00:00
commit d4b8048e9a
7 changed files with 642 additions and 285 deletions
Download patch file Download diff file Expand all files Collapse all files

338
Lib/python/boost_shared_ptr.i
View file

@ -39,11 +39,6 @@
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init, noblock=1) CONST TYPE {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE {
void *argp = 0;
int newmem = 0;
@ -80,14 +75,11 @@
$1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
}
}
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
}
%typemap(builtin_init, fragment="SWIG_null_deleter") CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE * {
void *argp = 0;
@ -132,10 +124,6 @@
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init, fragment="SWIG_null_deleter") CONST TYPE & {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE & {
void *argp = 0;
@ -180,10 +168,6 @@
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init, fragment="SWIG_null_deleter") TYPE *CONST& {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) TYPE *CONST& %{
#error "varin typemap not implemented"
@ -206,10 +190,6 @@
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
int newmem = 0;
@ -245,10 +225,6 @@
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
#error "varin typemap not implemented"
@ -277,11 +253,6 @@
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
if ($owner) delete $1;
}
%typemap(builtin_init) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
if ($owner) delete $1;
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
#error "varin typemap not implemented"
@ -306,10 +277,6 @@
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(builtin_init) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
#error "varin typemap not implemented"
@ -345,5 +312,308 @@
%template() SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >;
// Separate out the code for builtin types, since it's pretty extensive.
// I feel compelled to point out that the functionality provided by
// smart pointers is utterly redundant when using builtin types.
#if defined(SWIGPYTHON_BUILTIN)
/*
// plain value
%typemap(in) CONST TYPE (void *argp, int res = 0) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (!argp) {
%argument_nullref("$type", $symname, $argnum);
} else {
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
}
}
%typemap(out) CONST TYPE {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE {
void *argp = 0;
int newmem = 0;
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%variable_fail(res, "$type", "$name");
}
if (!argp) {
%argument_nullref("$type", $symname, $argnum);
} else {
$1 = *(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get());
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
}
}
%typemap(varout) CONST TYPE {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(new $1_ltype(($1_ltype &)$1));
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
// plain pointer
%typemap(builtin_init, fragment="SWIG_null_deleter") TYPE *, CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(TYPE *), $owner | SWIG_POINTER_OWN));
}
%typemap(in) CONST TYPE * (void *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (newmem & SWIG_CAST_NEW_MEMORY) {
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = %const_cast(tempshared.get(), $1_ltype);
} else {
smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
}
}
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), $owner | SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE * {
void *argp = 0;
int newmem = 0;
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%variable_fail(res, "$type", "$name");
}
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartarg = 0;
if (newmem & SWIG_CAST_NEW_MEMORY) {
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = %const_cast(tempshared.get(), $1_ltype);
} else {
smartarg = %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = %const_cast((smartarg ? smartarg->get() : 0), $1_ltype);
}
}
%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_0) : 0;
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(in) CONST TYPE & (void *argp = 0, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
if (newmem & SWIG_CAST_NEW_MEMORY) {
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = %const_cast(tempshared.get(), $1_ltype);
} else {
$1 = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
}
}
%typemap(out, fragment="SWIG_null_deleter") CONST TYPE & {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) CONST TYPE & {
void *argp = 0;
int newmem = 0;
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%variable_fail(res, "$type", "$name");
}
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared;
if (!argp) { %argument_nullref("$type", $symname, $argnum); }
if (newmem & SWIG_CAST_NEW_MEMORY) {
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
$1 = *%const_cast(tempshared.get(), $1_ltype);
} else {
$1 = *%const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $1_ltype);
}
}
%typemap(varout, fragment="SWIG_null_deleter") CONST TYPE & {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(&$1 SWIG_NO_NULL_DELETER_0);
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
// plain pointer by reference
// Note: $disown not implemented by default as it will lead to a memory leak of the shared_ptr instance
%typemap(in) TYPE *CONST& (void *argp = 0, int res = 0, $*1_ltype temp = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), SHARED_PTR_DISOWN | %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (newmem & SWIG_CAST_NEW_MEMORY) {
tempshared = *%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
delete %reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *);
temp = %const_cast(tempshared.get(), $*1_ltype);
} else {
temp = %const_cast(%reinterpret_cast(argp, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *)->get(), $*1_ltype);
}
$1 = &temp;
}
%typemap(out, fragment="SWIG_null_deleter") TYPE *CONST& {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1 SWIG_NO_NULL_DELETER_$owner);
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) TYPE *CONST& %{
#error "varin typemap not implemented"
%}
%typemap(varout) TYPE *CONST& %{
#error "varout typemap not implemented"
%}
// shared_ptr by value
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > (void *argp, int res = 0) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (argp) $1 = *(%reinterpret_cast(argp, $&ltype));
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
}
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
int newmem = 0;
void *argp = 0;
int res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%variable_fail(res, "$type", "$name");
}
$1 = argp ? *(%reinterpret_cast(argp, $&ltype)) : SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE >();
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $&ltype);
}
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1) : 0;
%set_varoutput(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
// shared_ptr by reference
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & (void *argp, int res = 0, $*1_ltype tempshared) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (newmem & SWIG_CAST_NEW_MEMORY) {
if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
delete %reinterpret_cast(argp, $ltype);
$1 = &tempshared;
} else {
$1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
}
}
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
#error "varin typemap not implemented"
%}
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > & %{
#error "varout typemap not implemented"
%}
// shared_ptr by pointer
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * (void *argp, int res = 0, $*1_ltype tempshared) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (newmem & SWIG_CAST_NEW_MEMORY) {
if (argp) tempshared = *%reinterpret_cast(argp, $ltype);
delete %reinterpret_cast(argp, $ltype);
$1 = &tempshared;
} else {
$1 = (argp) ? %reinterpret_cast(argp, $ltype) : &tempshared;
}
}
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 && *$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(*$1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
if ($owner) delete $1;
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
#error "varin typemap not implemented"
%}
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > * %{
#error "varout typemap not implemented"
%}
// shared_ptr by pointer reference
%typemap(in) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& (void *argp, int res = 0, SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > tempshared, $*1_ltype temp = 0) {
int newmem = 0;
res = SWIG_ConvertPtrAndOwn($input, &argp, $descriptor(TYPE *), %convertptr_flags, &newmem);
if (!SWIG_IsOK(res)) {
%argument_fail(res, "$type", $symname, $argnum);
}
if (argp) tempshared = *%reinterpret_cast(argp, $*ltype);
if (newmem & SWIG_CAST_NEW_MEMORY) delete %reinterpret_cast(argp, $*ltype);
temp = &tempshared;
$1 = &temp;
}
%typemap(out) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = *$1 && **$1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >(**$1) : 0;
%set_output(SWIG_NewPointerObj(%as_voidptr(smartresult), $descriptor(TYPE *), SWIG_POINTER_OWN));
}
%typemap(varin) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
#error "varin typemap not implemented"
%}
%typemap(varout) SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& %{
#error "varout typemap not implemented"
%}
// Typecheck typemaps
// Note: SWIG_ConvertPtr with void ** parameter set to 0 instead of using SWIG_ConvertPtrAndOwn, so that the casting
// function is not called thereby avoiding a possible smart pointer copy constructor call when casting up the inheritance chain.
%typemap(typecheck,precedence=SWIG_TYPECHECK_POINTER,noblock=1)
TYPE CONST,
TYPE CONST &,
TYPE CONST *,
TYPE *CONST&,
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >,
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > &,
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *,
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *& {
int res = SWIG_ConvertPtr($input, 0, $descriptor(TYPE *), 0);
$1 = SWIG_CheckState(res);
}
*/
%typemap(builtin_init, fragment="SWIG_null_deleter") CONST TYPE * {
SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE > *smartresult = $1 ? new SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< CONST TYPE >($1 SWIG_NO_NULL_DELETER_$owner) : 0;
%set_output(SWIG_Python_NewBuiltinObj(self, %as_voidptr(smartresult), $descriptor(SWIG_SHARED_PTR_QNAMESPACE::shared_ptr< TYPE > *), $owner | SWIG_POINTER_OWN));
}
#endif
%enddef

33
Lib/python/builtin.swg
View file

@ -5,6 +5,16 @@ wrapper##_closure (PyObject *a) \
return wrapper(a, NULL); \
}
#define PYSWIG_INQUIRY_CLOSURE(wrapper) \
SWIGINTERN int \
wrapper##_closure (PyObject *a) \
{ \
PyObject *pyresult = wrapper(a, NULL); \
int result = pyresult && PyObject_IsTrue(pyresult) ? 1 : 0; \
Py_XDECREF(pyresult); \
return result; \
}
#define PYSWIG_BINARYFUNC_CLOSURE(wrapper) \
SWIGINTERN PyObject* \
wrapper##_closure (PyObject *a, PyObject *b) \
@ -126,28 +136,9 @@ wrapper##_closure (PyObject *a, PyObject *b, PyObject *c) \
namespace {
template <typename _Tp> struct SwigPyBuiltin : public SwigPyObject {
typedef SwigPyBuiltin<_Tp> this_type;
typedef _Tp obj_type;
typedef obj_type* pointer;
typedef obj_type& reference;
static PyObject* richcompare (PyObject *self, PyObject *other, int op);
static PyMethodDef methods[];
static PyGetSetDef getset[];
static PyNumberMethods number_methods;
static PySequenceMethods sequence_methods;
static PyMappingMethods mapping_methods;
static PyTypeObject pytype;
static SwigPyClientData clientdata;
};
template <typename _Tp> void py_builtin_dealloc (PyObject *pyobj)
{
typedef SwigPyBuiltin<_Tp> builtin_type;
builtin_type *obj = (builtin_type*) pyobj;
SwigPyObject *obj = (SwigPyObject*) pyobj;
if (obj->own)
delete reinterpret_cast<_Tp*>(obj->ptr);
(*pyobj->ob_type->tp_free)(pyobj);
@ -168,7 +159,7 @@ SWIGRUNTIME void py_builtin_bad_dealloc (PyObject *pyobj)
SwigPyObject *sobj = (SwigPyObject*) pyobj;
if (sobj->own) {
PyErr_Format(PyExc_TypeError,
"Swig detected a memory leak in type '%s': no callable destructor found.",
"Swig detected a memory leak in type '%.300s': no callable destructor found.",
pyobj->ob_type->tp_name);
}
}

44
Lib/python/carrays.i
View file

@ -1,5 +1,49 @@
%define %array_class(TYPE,NAME)
#if defined(SWIGPYTHON_BUILTIN)
%feature("pyslot", "sq_item", functype="ssizeargfunc") NAME::__getitem__;
%feature("pyslot", "sq_ass_item", functype="ssizeobjargproc") NAME::__setitem__;
%inline %{
typedef struct NAME {
TYPE *el;
} NAME;
%}
%extend NAME {
NAME(size_t nelements) {
NAME *arr = %new_instance(NAME);
arr->el = %new_array(nelements, TYPE);
return arr;
}
~NAME() {
%delete_array(self->el);
%delete(self);
}
TYPE __getitem__(size_t index) {
return self->el[index];
}
void __setitem__(size_t index, TYPE value) {
self->el[index] = value;
}
TYPE * cast() {
return self->el;
}
static NAME *frompointer(TYPE *t) {
return %reinterpret_cast(t, NAME *);
}
};
%types(NAME = TYPE);
#else
%array_class_wrap(TYPE,NAME,__getitem__,__setitem__)
#endif
%enddef
%include <typemaps/carrays.swg>

2
Lib/python/pycontainer.swg
View file

@ -604,7 +604,7 @@ namespace swig
%newobject __getslice__;
#if defined(SWIGPYTHON_BUILTIN)
%feature("pyslot", "nb_nonzero", functype="unaryfunc") __nonzero__;
%feature("pyslot", "nb_nonzero", functype="inquiry") __nonzero__;
%feature("pyslot", "sq_length", functype="lenfunc") __len__;
#endif // SWIGPYTHON_BUILTIN

2
Lib/python/pyopers.swg
View file

@ -43,7 +43,7 @@
%feature("pyslot", "tp_call", functype="ternaryfunc") *::operator();
#if defined(SWIGPYTHON_BUILTIN)
%pybinoperator(__nonzero__, *::operator bool, unaryfunc, nb_nonzero);
%pybinoperator(__nonzero__, *::operator bool, inquiry, nb_nonzero);
#else
%feature("shadow") *::operator bool %{
def __nonzero__(self):

120
Lib/python/pyrun.swg
View file

@ -1033,50 +1033,61 @@ SWIG_This(void)
SWIGRUNTIME SwigPyObject *
SWIG_Python_GetSwigThis(PyObject *pyobj)
{
if (SwigPyObject_Check(pyobj)) {
if (SwigPyObject_Check(pyobj))
return (SwigPyObject *) pyobj;
} else {
PyObject *obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#ifdef SWIGPYTHON_BUILTIN
# ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
pyobj = PyWeakref_GET_OBJECT(pyobj);
if (pyobj && SwigPyObject_Check(pyobj))
return (SwigPyObject*) pyobj;
}
# endif
return NULL;
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
PyObject *obj = 0;
#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
if (PyInstance_Check(pyobj)) {
obj = _PyInstance_Lookup(pyobj, SWIG_This());
} else {
PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
if (dictptr != NULL) {
PyObject *dict = *dictptr;
obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
} else {
#ifdef PyWeakref_CheckProxy
if (PyWeakref_CheckProxy(pyobj)) {
PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
}
#endif
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
}
#else
obj = PyObject_GetAttr(pyobj,SWIG_This());
if (obj) {
Py_DECREF(obj);
} else {
if (PyErr_Occurred()) PyErr_Clear();
return 0;
}
#endif
if (obj && !SwigPyObject_Check(obj)) {
/* a PyObject is called 'this', try to get the 'real this'
SwigPyObject from it */
return SWIG_Python_GetSwigThis(obj);
}
return (SwigPyObject *)obj;
}
/* Acquire a pointer value */
@ -1104,22 +1115,27 @@ SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int
return SWIG_OK;
}
/*
if (ty && ty->clientdata && ((SwigPyClientData*) ty->clientdata)->pytype) {
PyTypeObject *target_tp = ((SwigPyClientData*) ty->clientdata)->pytype;
PyTypeObject *obj_tp;
for (obj_tp = obj->ob_type; obj_tp; obj_tp = obj_tp->tp_base) {
if (obj_tp == target_tp) {
SwigPyObject *sobj = (SwigPyObject*) obj;
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN)
sobj->own = 0;
if (ptr)
*ptr = sobj->ptr;
return SWIG_OK;
}
PyTypeObject *target_tp = ((SwigPyClientData*) ty->clientdata)->pytype;
SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
for (; sobj; sobj = (SwigPyObject*) sobj->next) {
if (!sobj->ty->clientdata)
continue;
PyTypeObject *candidate_tp = ((SwigPyClientData*) sobj->ty->clientdata)->pytype;
if (candidate_tp && PyType_IsSubtype(candidate_tp, target_tp)) {
if (own)
*own = *own | sobj->own;
if (flags & SWIG_POINTER_DISOWN)
sobj->own = 0;
if (ptr)
*ptr = sobj->ptr;
return SWIG_OK;
}
}
return SWIG_ERROR;
}
*/
int res = SWIG_ERROR;

388
Source/Modules/python.cxx
View file

@ -52,6 +52,7 @@ static Hash *builtin_getset = 0;
static Hash *class_members = 0;
static File *f_builtins = 0;
static String *builtin_tp_init = 0;
static String *builtin_methods = 0;
static String *methods;
static String *class_name;
@ -171,6 +172,7 @@ static String *getSlot(Node *n, const char *key) {
static String *getClosure(String *functype, String *wrapper) {
static const char *functypes[] = {
"unaryfunc", "PYSWIG_UNARYFUNC_CLOSURE",
"inquiry", "PYSWIG_INQUIRY_CLOSURE",
"getiterfunc", "PYSWIG_UNARYFUNC_CLOSURE",
"iternextfunc", "PYSWIG_UNARYFUNC_CLOSURE",
"binaryfunc", "PYSWIG_BINARYFUNC_CLOSURE",
@ -575,6 +577,7 @@ public:
f_directors = NewString("");
builtin_getset = NewHash();
class_members = NewHash();
builtin_methods = NewString("");
if (builtin) {
f_builtins = NewString("");
@ -906,6 +909,11 @@ public:
Append(methods, "};\n");
Printf(f_wrappers, "%s\n", methods);
if (builtin) {
Printv(f_builtins, "#ifdef __cplusplus\n} // namespace {\n#endif\n\n", NIL);
Dump(f_builtins, f_wrappers);
}
SwigType_emit_type_table(f_runtime, f_wrappers);
Append(const_code, "{0, 0, 0, 0.0, 0, 0}};\n");
@ -918,8 +926,6 @@ public:
Printf(f_init, " return;\n");
Printf(f_init, "#endif\n");
Printf(f_init, "}\n");
if (builtin)
Printv(f_builtins, "#ifdef __cplusplus\n} // namespace {\n#endif\n\n", NIL);
Printf(f_wrappers, "#ifdef __cplusplus\n");
Printf(f_wrappers, "}\n");
@ -951,8 +957,8 @@ public:
}
Dump(f_wrappers, f_begin);
if (builtin)
Dump(f_builtins, f_begin);
//if (builtin)
//Dump(f_builtins, f_begin);
Wrapper_pretty_print(f_init, f_begin);
Delete(f_header);
@ -1802,12 +1808,11 @@ public:
/* ------------------------------------------------------------
* dispatchFunction()
* ------------------------------------------------------------ */
void dispatchFunction(Node *n, String *linkage, int funpack = 0, bool builtin_self = false, bool constructor = false) {
void dispatchFunction(Node *n, String *linkage, int funpack = 0, bool return_int = false, bool add_self = false, bool addmeth = true) {
/* Last node in overloaded chain */
int maxargs;
bool return_int = (builtin_self && constructor);
String *tmp = NewString("");
String *dispatch;
const char *dispatch_code = funpack ? "return %s(self, argc, argv);" : "return %s(self, args);";
@ -1831,8 +1836,6 @@ public:
Wrapper_add_local(f, "argv", tmp);
if (!fastunpack) {
bool director_class = (getCurrentClass() && Swig_directorclass(getCurrentClass()));
bool add_self = builtin_self && (!constructor || director_class);
Wrapper_add_local(f, "ii", "int ii");
if (maxargs - (add_self ? 1 : 0) > 0)
Append(f->code, "if (!PyTuple_Check(args)) SWIG_fail;\n");
@ -1875,7 +1878,7 @@ public:
Printv(f->code, "}\n", NIL);
Wrapper_print(f, f_wrappers);
Node *p = Getattr(n, "sym:previousSibling");
if (!builtin_self)
if (addmeth)
add_method(symname, wname, 0, p);
/* Create a shadow for this function (if enabled and not in a member function) */
@ -1949,7 +1952,15 @@ public:
Delete(cname);
}
bool builtin_self = builtin && in_class && (constructor || (l && Getattr(l, "self")));
bool builtin_ctor = builtin_self && constructor;
bool builtin_ctor = false;
if (builtin_self && constructor) {
String *class_mname = Getattr(getCurrentClass(), "sym:name");
String *mrename = Swig_name_construct(getNSpace(), class_mname);
if (Cmp(iname, mrename))
builtin_self = false;
else
builtin_ctor = true;
}
bool director_class = (getCurrentClass() && Swig_directorclass(getCurrentClass()));
bool builtin_getter = (builtin && GetFlag(n, "memberget"));
bool builtin_setter = (builtin && GetFlag(n, "memberset") && !builtin_getter);
@ -1994,7 +2005,7 @@ public:
/* Get number of required and total arguments */
tuple_arguments = num_arguments = emit_num_arguments(l);
tuple_required = num_required = emit_num_required(l);
if (builtin_self && (!constructor || (constructor && director_class))) {
if (builtin_self && (!builtin_ctor || (builtin_ctor && director_class))) {
--tuple_arguments;
--tuple_required;
}
@ -2493,7 +2504,7 @@ public:
DelWrapper(f);
f = NewWrapper();
Printv(f->def, linkage, wrap_return, wname, "(PyObject *self, PyObject *args) {", NIL);
Wrapper_add_local(f, "resultobj", constructor && builtin_self ? "int resultobj" : "PyObject *resultobj");
Wrapper_add_local(f, "resultobj", builtin_ctor ? "int resultobj" : "PyObject *resultobj");
Wrapper_add_local(f, "varargs", "PyObject *varargs");
Wrapper_add_local(f, "newargs", "PyObject *newargs");
int first_arg = builtin_self ? 1 : 0;
@ -2518,7 +2529,10 @@ public:
}
} else {
if (!Getattr(n, "sym:nextSibling")) {
dispatchFunction(n, linkage, funpack, builtin_self, constructor);
dispatchFunction(n, linkage, funpack,
builtin_ctor, // return_int
builtin_self && (!builtin_ctor || director_class), // add_self
!builtin_self); // addmeth
}
}
@ -2991,7 +3005,7 @@ public:
if (shadow) {
if (builtin) {
String *rname = SwigType_namestr(real_classname);
Printf(f_shadow, tab4 "{ \"__disown__\", (PyCFunction) Swig::Director::pyobj_disown< %s >, METH_NOARGS, \"\" },\n", rname);
Printf(builtin_methods, tab4 "{ \"__disown__\", (PyCFunction) Swig::Director::pyobj_disown< %s >, METH_NOARGS, \"\" },\n", rname);
Delete(rname);
} else {
String *symname = Getattr(n, "sym:name");
@ -3019,28 +3033,6 @@ public:
* classDeclaration()
* ------------------------------------------------------------ */
virtual bool get_single_base(Node *n, Node **base = NULL) {
if (base)
*base = NULL;
if (Getattr(n, "single_inh"))
return true;
List *baselist = Getattr(n, "bases");
if (!baselist || Len(baselist) == 0) {
Setattr(n, "single_inh", "1");
return true;
}
//if (baselist && Len(baselist) == 1) {
Iterator b = First(baselist);
if (this->get_single_base(b.item)) {
if (base)
*base = b.item;
Setattr(n, "single_inh", "1");
return true;
}
//}
return false;
}
virtual int classDeclaration(Node *n) {
if (shadow && !Getattr(n, "feature:onlychildren")) {
Node *mod = Getattr(n, "module");
@ -3068,43 +3060,26 @@ public:
* classHandler()
* ------------------------------------------------------------ */
String* add_explicit_scope (String *s) {
if (!Strstr(s, "::")) {
String *ss = NewStringf("::%s", s);
Delete(s);
s = ss;
}
return s;
String* add_explicit_scope (String *s) {
if (!Strstr(s, "::")) {
String *ss = NewStringf("::%s", s);
Delete(s);
s = ss;
}
return s;
}
void builtin_pre_decl(Node *n, Node *) {
void builtin_pre_decl(Node *n) {
String *name = Getattr(n, "name");
String *rname = add_explicit_scope(SwigType_namestr(name));
String *mname = SwigType_manglestr(rname);
Printf(f_init, "\n// type '%s'\n", rname);
Printf(f_init, tab4 "builtin_pytype = &SwigPyBuiltin< %s >::pytype;\n", rname);
Printf(f_init, tab4 "builtin_pytype->ob_type = metatype;\n");
Printf(f_init, tab4 "builtin_pytype->tp_new = PyType_GenericNew;\n");
List *baselist = Getattr(n, "bases");
if (baselist) {
for (Iterator b = First(baselist); b.item; b = Next(b)) {
String *bname = Getattr(b.item, "name");
if (!bname || GetFlag(b.item, "feature:ignore"))
continue;
String *base_name = Copy(bname);
SwigType_add_pointer(base_name);
String *base_mname = SwigType_manglestr(base_name);
Printf(f_init, " builtin_basetype = SWIG_MangledTypeQuery(\"%s\");\n", base_mname);
Printv(f_init, " if (builtin_basetype && builtin_basetype->clientdata && ((SwigPyClientData*) builtin_basetype->clientdata)->pytype) {\n", NIL);
Printv(f_init, " builtin_bases.push_back(((SwigPyClientData*) builtin_basetype->clientdata)->pytype);\n", NIL);
Printv(f_init, " }\n", NIL);
Delete(base_name);
Delete(base_mname);
}
}
Printv(f_init, " pyswig_builtin_init_bases(builtin_pytype, builtin_bases);\n", NIL);
Printv(f_init, " builtin_bases.clear();\n", NIL);
Printf(f_init, " builtin_pytype = (PyTypeObject*) &SwigPyBuiltin_%s_type;\n", mname);
Printf(f_init, " builtin_pytype->tp_dict = d = PyDict_New();\n");
Delete(rname);
Delete(mname);
}
virtual bool has_callable_dtor (Node *n, bool protected_ok = false) {
@ -3127,21 +3102,44 @@ public:
SwigType_add_pointer(pname);
String *symname = Getattr(n, "sym:name");
String *rname = add_explicit_scope(SwigType_namestr(name));
String *templ = NewString("");
Printf(templ, "SwigPyBuiltin< %s >", rname);
char const *tp_init = builtin_tp_init ? Char(builtin_tp_init) : Swig_directorclass(n) ? "0" : "py_builtin_bad_init";
String *mname = SwigType_manglestr(rname);
String *templ = NewStringf("SwigPyBuiltin_%s", mname);
Printf(f_init, tab4 "builtin_pytype->ob_type = metatype;\n");
Printf(f_init, tab4 "builtin_pytype->tp_new = PyType_GenericNew;\n");
List *baselist = Getattr(n, "bases");
if (baselist) {
for (Iterator b = First(baselist); b.item; b = Next(b)) {
String *bname = Getattr(b.item, "name");
if (!bname || GetFlag(b.item, "feature:ignore"))
continue;
String *base_name = Copy(bname);
SwigType_add_pointer(base_name);
String *base_mname = SwigType_manglestr(base_name);
Printf(f_init, " builtin_basetype = SWIG_MangledTypeQuery(\"%s\");\n", base_mname);
Printv(f_init, " if (builtin_basetype && builtin_basetype->clientdata && ((SwigPyClientData*) builtin_basetype->clientdata)->pytype) {\n", NIL);
Printv(f_init, " builtin_bases.push_back(((SwigPyClientData*) builtin_basetype->clientdata)->pytype);\n", NIL);
Printv(f_init, " }\n", NIL);
Delete(base_name);
Delete(base_mname);
}
}
Printv(f_init, " pyswig_builtin_init_bases(builtin_pytype, builtin_bases);\n", NIL);
Printv(f_init, " builtin_bases.clear();\n", NIL);
// Check for non-public destructor, in which case tp_dealloc will issue
// a warning and allow the memory to leak. Any class that doesn't explicitly
// have a private/protected destructor has an implicit public destructor.
String *tp_dealloc = NewString("");
if (has_callable_dtor(n))
Printf(tp_dealloc, "py_builtin_dealloc< %s >", rname);
else
if (has_callable_dtor(n)) {
String *smartptr = Getattr(n, "feature:smartptr");
Printf(tp_dealloc, "py_builtin_dealloc< %s >", smartptr ? smartptr : rname);
} else {
Printv(tp_dealloc, "py_builtin_bad_dealloc", NIL);
}
String *getset_def = NewString("");
Printf(getset_def, "template <> PyGetSetDef SwigPyBuiltin< %s >::getset[] = {\n", rname);
Printf(getset_def, "SWIGINTERN PyGetSetDef %s_getset[] = {\n", templ);
// All objects have a 'thisown' attribute
Printv(f_init, "PyDict_SetItemString(d, \"thisown\", thisown_descr);\n", NIL);
@ -3158,19 +3156,100 @@ public:
Printf(f, "static SwigPyGetSet %s = { %s, %s };\n", gspair, getter ? getter : "0", setter ? setter : "0");
String *entry = NewStringf("{ const_cast<char*>(\"%s\"), (getter) %s, (setter) %s, const_cast<char*>(\"%s.%s\"), (void*) &%s }\n", memname, getter_closure, setter_closure, name, memname, gspair);
if (GetFlag(mgetset, "static")) {
Printf(f, "static PyGetSetDef %s_def = %s;\n", gspair, entry);
Printf(f_init, "static_getset = SwigPyStaticVar_new_getset(metatype, &%s_def);\n", gspair);
Printf(f_init, "PyDict_SetItemString(d, static_getset->d_getset->name, (PyObject*) static_getset);\n", memname); Printf(f_init, "Py_DECREF(static_getset);\n");
Printf(f, "static PyGetSetDef %s_def = %s;\n", gspair, entry);
Printf(f_init, "static_getset = SwigPyStaticVar_new_getset(metatype, &%s_def);\n", gspair);
Printf(f_init, "PyDict_SetItemString(d, static_getset->d_getset->name, (PyObject*) static_getset);\n", memname); Printf(f_init, "Py_DECREF(static_getset);\n");
} else {
Printf(getset_def, " %s,\n", entry);
Printf(getset_def, " %s,\n", entry);
}
Delete(gspair);
Delete(entry);
}
Printv(f, getset_def, " {NULL} // Sentinel\n", "};\n\n", NIL);
// Number methods
Printf(f, "template <> PyNumberMethods SwigPyBuiltin< %s >::number_methods = {\n", rname);
// Rich compare function
Hash *richcompare = Getattr(n, "richcompare");
assert(richcompare);
Printf(f, "SWIGINTERN PyObject*\n");
Printf(f, "%s_richcompare (PyObject *self, PyObject *other, int op)\n", templ);
Printf(f, "{\n");
Printf(f, " PyObject *result = NULL;\n");
Printf(f, " PyObject *tuple = PyTuple_New(1);\n");
Printf(f, " assert(tuple);\n");
Printf(f, " PyTuple_SET_ITEM(tuple, 0, other);\n");
Printf(f, " Py_XINCREF(other);\n");
Printf(f, " switch (op) {\n");
for (Iterator i = First(richcompare); i.item; i = Next(i))
Printf(f, " case %s : result = %s(self, tuple); break;\n", i.key, i.item);
Printv(f, " default : PyErr_Format(PyExc_TypeError, \"Cannot compare a(n) '%s' to a(n) '%s'\",", NIL);
Printv(f, " self->ob_type->tp_name, other ? other->ob_type->tp_name : \"NULL\");\n", NIL);
Printf(f, " }\n");
Printf(f, " Py_DECREF(tuple);\n");
Printf(f, " return result;\n");
Printf(f, "}\n\n");
// Methods
Printf(f, "SWIGINTERN PyMethodDef %s_methods[] = {\n", templ);
Dump(builtin_methods, f);
Printf(f, " {NULL} // Sentinel\n};\n\n");
// No instance dict for nondynamic objects
if (GetFlag(n, "feature:python:nondynamic"))
Setattr(n, "feature:tp_setattro", "SWIG_Python_NonDynamicSetAttr");
char const *tp_init = builtin_tp_init ? Char(builtin_tp_init) : Swig_directorclass(n) ? "0" : "py_builtin_bad_init";
String *tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES");
Printf(f, "static PyHeapTypeObject %s_type = {\n", templ);
// PyTypeObject ht_type
//Printf(f, "template <> PyTypeObject %s::pytype = {\n", templ);
Printf(f, " {\n");
Printf(f, " PyObject_HEAD_INIT(NULL)\n");
Printf(f, " 0, /*ob_size*/\n");
Printf(f, " \"%s\", /*tp_name*/\n", symname);
Printf(f, " sizeof(SwigPyObject), /*tp_basicsize*/\n", templ);
Printf(f, " %s, /*tp_itemsize*/\n", getSlot(n, "feature:tp_itemsize"));
Printf(f, " %s, /*tp_dealloc*/\n", tp_dealloc);
Printf(f, " %s, /*tp_print*/\n", getSlot(n, "feature:tp_print"));
Printf(f, " %s, /*tp_getattr*/\n", getSlot(n, "feature:tp_getattr"));
Printf(f, " %s, /*tp_setattr*/\n", getSlot(n, "feature:tp_setattr"));
Printf(f, " %s, /*tp_compare*/\n", getSlot(n, "feature:tp_compare"));
Printf(f, " %s, /*tp_repr*/\n", getSlot(n, "feature:tp_repr"));
Printf(f, " &%s_type.as_number, /*tp_as_number*/\n", templ);
Printf(f, " &%s_type.as_sequence, /*tp_as_sequence*/\n", templ);
Printf(f, " &%s_type.as_mapping, /*tp_as_mapping*/\n", templ);
Printf(f, " %s, /*tp_hash */\n", getSlot(n, "feature:tp_hash"));
Printf(f, " %s, /*tp_call*/\n", getSlot(n, "feature:tp_call"));
Printf(f, " %s, /*tp_str*/\n", getSlot(n, "feature:tp_str"));
Printf(f, " %s, /*tp_getattro*/\n", getSlot(n, "feature:tp_getattro"));
Printf(f, " %s, /*tp_setattro*/\n", getSlot(n, "feature:tp_setattro"));
Printf(f, " &%s_type.as_buffer, /*tp_as_buffer*/\n", templ);
Printf(f, " %s, /*tp_flags*/\n", tp_flags);
Printf(f, " \"%s\", /* tp_doc */\n", rname);
Printf(f, " %s, /* tp_traverse */\n", getSlot(n, "feature:tp_traverse"));
Printf(f, " %s, /* tp_clear */\n", getSlot(n, "feature:tp_clear"));
Printf(f, " %s_richcompare, /* tp_richcompare */\n", templ);
Printf(f, " %s, /* tp_weaklistoffset */\n", getSlot(n, "feature:tp_weaklistoffset"));
Printf(f, " (getiterfunc) %s, /* tp_iter */\n", getSlot(n, "feature:tp_iter"));
Printf(f, " (iternextfunc) %s, /* tp_iternext */\n", getSlot(n, "feature:tp_iternext"));
Printf(f, " %s_methods, /* tp_methods */\n", templ);
Printf(f, " %s, /* tp_members */\n", getSlot(n, "feature:tp_members"));
Printf(f, " %s_getset, /* tp_getset */\n", templ);
Printf(f, " %s, /* tp_base */\n", getSlot(n, "feature:tp_base"));
Printf(f, " %s, /* tp_dict */\n", getSlot(n, "feature:tp_dict"));
Printf(f, " %s, /* tp_descr_get */\n", getSlot(n, "feature:tp_descr_get"));
Printf(f, " %s, /* tp_descr_set */\n", getSlot(n, "feature:tp_descr_set"));
Printf(f, " (size_t)(((char*)&((SwigPyObject *) 64L)->dict) - (char*) 64L), /* tp_dictoffset */\n");
Printf(f, " (initproc)%s, /* tp_init */\n", tp_init);
Printf(f, " %s, /* tp_alloc */\n", getSlot(n, "feature:tp_alloc"));
Printf(f, " 0, /* tp_new */\n");
Printf(f, " %s /* tp_free */\n", getSlot(n, "feature:tp_free"));
Printf(f, " },\n");
// PyNumberMethods as_number
//Printf(f, "template <> PyNumberMethods %s::number_methods = {\n", templ);
Printf(f, " {\n");
Printf(f, " (binaryfunc) %s, // nb_add;\n", getSlot(n, "feature:nb_add"));
Printf(f, " (binaryfunc) %s, // nb_subtract;\n", getSlot(n, "feature:nb_subtract"));
Printf(f, " (binaryfunc) %s, // nb_multiply;\n", getSlot(n, "feature:nb_multiply"));
@ -3210,10 +3289,19 @@ public:
Printf(f, " (binaryfunc) %s, // nb_inplace_floor_divide;\n", getSlot(n, "feature:nb_inplace_floor_divide"));
Printf(f, " (binaryfunc) %s, // nb_inplace_true_divide;\n", getSlot(n, "feature:nb_inplace_true_divide"));
Printf(f, " (unaryfunc) %s, // nb_index;\n", getSlot(n, "feature:nb_index"));
Printf(f, "};\n\n");
Printf(f, " },\n");
// Sequence methods
Printf(f, "template <> PySequenceMethods SwigPyBuiltin< %s >::sequence_methods = {\n", rname);
// PyMappingMethods as_mapping;
//Printf(f, "template <> PyMappingMethods %s::mapping_methods = {\n", templ);
Printf(f, " {\n");
Printf(f, " (lenfunc) %s, // mp_length;\n", getSlot(n, "feature:mp_length"));
Printf(f, " (binaryfunc) %s, // mp_subscript;\n", getSlot(n, "feature:mp_subscript"));
Printf(f, " (objobjargproc) %s, // mp_ass_subscript;\n", getSlot(n, "feature:mp_ass_subscript"));
Printf(f, " },\n");
// PySequenceMethods as_sequence;
//Printf(f, "template <> PySequenceMethods %s::sequence_methods = {\n", templ);
Printf(f, " {\n");
Printf(f, " (lenfunc) %s, // sq_length\n", getSlot(n, "feature:sq_length"));
Printf(f, " (binaryfunc) %s, // sq_concat\n", getSlot(n, "feature:sq_concat"));
Printf(f, " (ssizeargfunc) %s, // sq_repeat\n", getSlot(n, "feature:sq_repeat"));
@ -3224,94 +3312,39 @@ public:
Printf(f, " (objobjproc) %s, // sq_contains\n", getSlot(n, "feature:sq_contains"));
Printf(f, " (binaryfunc) %s, // sq_inplace_concat\n", getSlot(n, "feature:sq_inplace_concat"));
Printf(f, " (ssizeargfunc) %s, // sq_inplace_repeat\n", getSlot(n, "feature:sq_inplace_repeat"));
Printf(f, "};\n\n");
Printf(f, " },\n");
// Mapping methods
Printf(f, "template <> PyMappingMethods SwigPyBuiltin< %s >::mapping_methods = {\n", rname);
Printf(f, " (lenfunc) %s, // mp_length;\n", getSlot(n, "feature:mp_length"));
Printf(f, " (binaryfunc) %s, // mp_subscript;\n", getSlot(n, "feature:mp_subscript"));
Printf(f, " (objobjargproc) %s, // mp_ass_subscript;\n", getSlot(n, "feature:mp_ass_subscript"));
Printf(f, "};\n\n");
// PyBufferProcs as_buffer;
Printf(f, " {\n");
Printf(f, " (readbufferproc) %s, // bf_getreadbuffer\n", getSlot(n, "feature:bf_getreadbuffer"));
Printf(f, " (writebufferproc) %s, // bf_getwritebuffer\n", getSlot(n, "feature:bf_getwritebuffer"));
Printf(f, " (segcountproc) %s, // bf_getsegcount\n", getSlot(n, "feature:bf_getsegcount"));
Printf(f, " (charbufferproc) %s, // bf_getcharbuffer\n", getSlot(n, "feature:bf_getcharbuffer"));
Printf(f, " },\n");
// Rich compare function
Printf(f, "template <> PyObject*\n");
Printf(f, "%s::richcompare (PyObject *self, PyObject *other, int op)\n", templ);
Printf(f, "{\n");
Printf(f, " PyObject *result = NULL;\n");
Printf(f, " PyObject *tuple = PyTuple_New(1);\n");
Printf(f, " assert(tuple);\n");
Printf(f, " PyTuple_SET_ITEM(tuple, 0, other);\n");
Printf(f, " Py_XINCREF(other);\n");
Printf(f, " switch (op) {\n");
Hash *richcompare = Getattr(n, "richcompare");
assert(richcompare);
for (Iterator i = First(richcompare); i.item; i = Next(i))
Printf(f, " case %s : result = %s(self, tuple); break;\n", i.key, i.item);
Printf(f, " default : PyErr_Format(PyExc_TypeError, \"Cannot compare a(n) '%%s' to a(n) '%%s'\", self->ob_type->tp_name, other ? other->ob_type->tp_name : \"NIL\");\n");
Printf(f, " }\n");
Printf(f, " Py_DECREF(tuple);\n");
Printf(f, " return result;\n");
Printf(f, "}\n\n");
if (GetFlag(n, "feature:python:nondynamic"))
Setattr(n, "feature:tp_setattro", "SWIG_Python_NonDynamicSetAttr");
// Type object
String *tp_flags = NewString("Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_CHECKTYPES");
// TODO: Add more flags based on slots
Printf(f, "template <> PyTypeObject SwigPyBuiltin< %s >::pytype = {\n", rname);
Printf(f, " PyObject_HEAD_INIT(NULL)\n");
Printf(f, " 0, /*ob_size*/\n");
Printf(f, " \"%s\", /*tp_name*/\n", symname);
Printf(f, " sizeof(%s), /*tp_basicsize*/\n", templ);
Printf(f, " %s, /*tp_itemsize*/\n", getSlot(n, "feature:tp_itemsize"));
Printf(f, " %s, /*tp_dealloc*/\n", tp_dealloc);
Printf(f, " %s, /*tp_print*/\n", getSlot(n, "feature:tp_print"));
Printf(f, " %s, /*tp_getattr*/\n", getSlot(n, "feature:tp_getattr"));
Printf(f, " %s, /*tp_setattr*/\n", getSlot(n, "feature:tp_setattr"));
Printf(f, " %s, /*tp_compare*/\n", getSlot(n, "feature:tp_compare"));
Printf(f, " %s, /*tp_repr*/\n", getSlot(n, "feature:tp_repr"));
Printf(f, " &%s::number_methods, /*tp_as_number*/\n", templ);
Printf(f, " &%s::sequence_methods, /*tp_as_sequence*/\n", templ);
Printf(f, " &%s::mapping_methods, /*tp_as_mapping*/\n", templ);
Printf(f, " %s, /*tp_hash */\n", getSlot(n, "feature:tp_hash"));
Printf(f, " %s, /*tp_call*/\n", getSlot(n, "feature:tp_call"));
Printf(f, " %s, /*tp_str*/\n", getSlot(n, "feature:tp_str"));
Printf(f, " %s, /*tp_getattro*/\n", getSlot(n, "feature:tp_getattro"));
Printf(f, " %s, /*tp_setattro*/\n", getSlot(n, "feature:tp_setattro"));
Printf(f, " %s, /*tp_as_buffer*/\n", getSlot(n, "feature:tp_as_buffer"));
Printf(f, " %s, /*tp_flags*/\n", tp_flags);
Printf(f, " \"%s\", /* tp_doc */\n", rname);
Printf(f, " %s, /* tp_traverse */\n", getSlot(n, "feature:tp_traverse"));
Printf(f, " %s, /* tp_clear */\n", getSlot(n, "feature:tp_clear"));
Printf(f, " %s::richcompare, /* tp_richcompare */\n", templ);
Printf(f, " %s, /* tp_weaklistoffset */\n", getSlot(n, "feature:tp_weaklistoffset"));
Printf(f, " (getiterfunc) %s, /* tp_iter */\n", getSlot(n, "feature:tp_iter"));
Printf(f, " (iternextfunc) %s, /* tp_iternext */\n", getSlot(n, "feature:tp_iternext"));
Printf(f, " %s::methods, /* tp_methods */\n", templ);
Printf(f, " %s, /* tp_members */\n", getSlot(n, "feature:tp_members"));
Printf(f, " %s::getset, /* tp_getset */\n", templ);
Printf(f, " %s, /* tp_base */\n", getSlot(n, "feature:tp_base"));
Printf(f, " %s, /* tp_dict */\n", getSlot(n, "feature:tp_dict"));
Printf(f, " %s, /* tp_descr_get */\n", getSlot(n, "feature:tp_descr_get"));
Printf(f, " %s, /* tp_descr_set */\n", getSlot(n, "feature:tp_descr_set"));
Printf(f, " (size_t)(((char*)&((SwigPyObject *) 64L)->dict) - (char*) 64L), /* tp_dictoffset */\n");
Printf(f, " (initproc)%s, /* tp_init */\n", tp_init);
Printf(f, " %s, /* tp_alloc */\n", getSlot(n, "feature:tp_alloc"));
Printf(f, " 0, /* tp_new */\n");
Printf(f, " %s /* tp_free */\n", getSlot(n, "feature:tp_free"));
// PyObject *ht_name, *ht_slots
Printf(f, " (PyObject*) %s, // ht_name\n", getSlot(n, "feature:ht_name"));
Printf(f, " (PyObject*) %s, // ht_slots\n", getSlot(n, "feature:ht_slots"));
Printf(f, "};\n\n");
String *clientdata = NewString("");
Printf(clientdata, "&%s::clientdata", templ);
Printf(clientdata, "&%s_clientdata", templ);
SwigType_remember_clientdata(pname, clientdata);
Printf(f, "template <> SwigPyClientData %s::clientdata = {0, 0, 0, 0, 0, 0, &%s::pytype};\n\n", templ, templ);
String *smartptr = Getattr(n, "feature:smartptr");
if (smartptr) {
SwigType *spt = Swig_cparse_type(smartptr);
SwigType *smart = SwigType_typedef_resolve_all(spt);
SwigType_add_pointer(smart);
SwigType_remember_clientdata(smart, clientdata);
Delete(spt);
Delete(smart);
}
Printf(f, "SWIGINTERN SwigPyClientData %s_clientdata = {0, 0, 0, 0, 0, 0, (PyTypeObject*) &%s_type};\n\n", templ, templ);
Printv(f_init, " if (PyType_Ready(builtin_pytype) < 0) {\n", NIL);
Printf(f_init, " PyErr_Format(PyExc_TypeError, \"Couldn't create type '.300%s'\");\n", symname);
Printf(f_init, " PyErr_SetString(PyExc_TypeError, \"Couldn't create type '%s'\");\n", symname);
Printv(f_init, " return;\n", NIL);
Printv(f_init, " }\n", NIL);
Printv(f_init, " Py_INCREF(builtin_pytype);\n", NIL);
@ -3320,9 +3353,10 @@ public:
Printv(f_init, " d = md;\n", NIL);
Delete(clientdata);
Delete(templ);
Delete(rname);
Delete(pname);
Delete(mname);
Delete(templ);
Delete(tp_dealloc);
Delete(tp_flags);
}
@ -3358,10 +3392,12 @@ public:
if (!addSymbol(class_name, n))
return SWIG_ERROR;
if (builtin && !get_single_base(n, &base_node)) {
Swig_warning(WARN_PYTHON_MULTIPLE_INH, Getfile(n), Getline(n),
"Class '%s' ignored, because it has multiple inheritance, which is incompatible with the '-builtin' option.\n", real_classname);
return SWIG_OK;
if (builtin) {
List *baselist = Getattr(n, "bases");
if (baselist && Len(baselist) > 0) {
Iterator b = First(baselist);
base_node = b.item;
}
}
shadow_indent = (String *) tab4;
@ -3470,7 +3506,7 @@ public:
in_class = 1;
if (builtin)
builtin_pre_decl(n, base_node);
builtin_pre_decl(n);
/* Overide the shadow file so we can capture its methods */
f_shadow = NewString("");
@ -3562,12 +3598,8 @@ public:
Delete(rname);
}
if (builtin) {
if (builtin)
builtin_post_decl(f_builtins, n);
String *rname = add_explicit_scope(SwigType_namestr(real_classname));
Printf(f_builtins, "template <> PyMethodDef SwigPyBuiltin< %s >::methods[] = {\n", rname);
Delete(rname);
}
if (builtin_tp_init) {
Delete(builtin_tp_init);
@ -3611,10 +3643,12 @@ public:
}
if (builtin) {
Dump(f_shadow, f_builtins);
Printf(f_builtins, " {NULL} // Sentinel\n};\n\n");
//Dump(f_shadow, f_builtins);
//Printf(f_builtins, " {NULL} // Sentinel\n};\n\n");
//Dump(builtin_methods, f_builtins);
Clear(class_members);
Clear(builtin_getset);
Clear(builtin_methods);
}
classic = oldclassic;
@ -3675,7 +3709,7 @@ public:
String *wname = Swig_name_wrapper(fullname);
Setattr(class_members, symname, n);
int allow_kwargs = check_kwargs(n);
Printf(f_shadow, " { \"%s\", (PyCFunction) %s, METH_VARARGS%s, \"\" },\n",
Printf(builtin_methods, " { \"%s\", (PyCFunction) %s, METH_VARARGS%s, \"\" },\n",
symname, wname, allow_kwargs ? "|METH_KEYWORDS" : "");
Delete(fullname);
Delete(wname);
@ -3763,7 +3797,7 @@ public:
String *wname = Swig_name_wrapper(fullname);
Setattr(class_members, symname, n);
String *pyflags = NewString("METH_VARARGS|METH_STATIC");
Printf(f_shadow, " { \"%s\", (PyCFunction) %s, %s, \"\" },\n", symname, wname, pyflags);
Printf(builtin_methods, " { \"%s\", (PyCFunction) %s, %s, \"\" },\n", symname, wname, pyflags);
Delete(fullname);
Delete(wname);
Delete(pyflags);
@ -3926,9 +3960,11 @@ public:
if (have_pythonprepend(n))
Printv(f_shadow_stubs, pythoncode(pythonprepend(n), tab4), "\n", NIL);
String *subfunc = NULL;
/*
if (builtin)
subfunc = Copy(Getattr(getCurrentClass(), "sym:name"));
else
*/
subfunc = Swig_name_construct(NSPACE_TODO, symname);
Printv(f_shadow_stubs, tab4, "val = ", funcCall(subfunc, callParms), "\n", NIL);
#ifdef USE_THISOWN