int
Swig_MembersetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
Parm *p;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self= 0;
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
name = Getattr(n,"name");
type = Getattr(n,"type");
membername = Swig_name_member(classname, Swig_name_set(name));
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t,"self");
Delete(t);
ty = Swig_wrapped_var_type(type);
p = NewParm(ty,name);
set_nextSibling(parms,p);
/* If the type is a pointer or reference. We mark it with a special wrap:disown attribute */
if (SwigType_check_decl(type,"p.")) {
Setattr(p,"wrap:disown","1");
}
Delete(p);
if (flags & CWRAP_EXTEND) {
String *code = Getattr(n,"code");
if (code) {
String *s = NewStringf("void %s(%s)", mangled, ParmList_str(parms));
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cfunction_call(mangled,parms)));
} else {
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cmemberset_call(name,type,self)));
}
Setattr(n,"type","void");
Setattr(n,"parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(mangled);
Delete(self);
return SWIG_OK;
}
String *Swig_cfunction_call(String_or_char *name, ParmList *parms) {
String *func;
int i = 0;
int comma = 0;
Parm *p = parms;
String *nname;
func = NewStringEmpty();
nname = SwigType_namestr(name);
/*
SWIGTEMPLATEDISAMBIGUATOR is compiler dependent (swiglabels.swg),
- SUN Studio 9 requires 'template',
- gcc-3.4 forbids the use of 'template'.
the rest seems not caring very much,
*/
if (SwigType_istemplate(name)) {
String *prefix = Swig_scopename_prefix(nname);
if (!prefix || Len(prefix) == 0) {
Printf(func, "%s(", nname);
} else {
String *last = Swig_scopename_last(nname);
Printf(func, "%s::SWIGTEMPLATEDISAMBIGUATOR %s(", prefix, last);
Delete(last);
}
Delete(prefix);
} else {
Printf(func, "%s(", nname);
}
Delete(nname);
while (p) {
SwigType *pt = Getattr(p, k_type);
if ((SwigType_type(pt) != T_VOID)) {
SwigType *rpt = SwigType_typedef_resolve_all(pt);
String *pname = Swig_cparm_name(p, i);
String *rcaststr = SwigType_rcaststr(rpt, pname);
if (comma) {
Printv(func, ",", rcaststr, NIL);
} else {
Append(func, rcaststr);
}
Delete(rpt);
Delete(pname);
Delete(rcaststr);
comma = 1;
i++;
}
p = nextSibling(p);
}
Append(func, ")");
return func;
}
/* -----------------------------------------------------------------------------
* extension_code()
*
* Generates an extension function (a function defined in %extend)
*
* return_type function_name(parms) code
*
* ----------------------------------------------------------------------------- */
static String *extension_code(const String *function_name, ParmList *parms, SwigType *return_type, const String *code, int cplusplus, const String *self) {
String *parms_str = cplusplus ? ParmList_str_defaultargs(parms) : ParmList_str(parms);
String *sig = NewStringf("%s(%s)", function_name, parms_str);
String *rt_sig = SwigType_str(return_type, sig);
String *body = NewStringf("SWIGINTERN %s", rt_sig);
Printv(body, code, "\n", NIL);
if (self)
Replaceall(body, "$self", self);
Delete(parms_str);
Delete(sig);
Delete(rt_sig);
return body;
}
int
Swig_MembergetToFunction(Node *n, String *classname, int flags) {
String *name;
ParmList *parms;
SwigType *t;
SwigType *ty;
SwigType *type;
String *membername;
String *mangled;
String *self = 0;
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
name = Getattr(n,"name");
type = Getattr(n,"type");
membername = Swig_name_member(classname, Swig_name_get(name));
mangled = Swig_name_mangle(membername);
t = NewString(classname);
SwigType_add_pointer(t);
parms = NewParm(t,"self");
Delete(t);
ty = Swig_wrapped_var_type(type);
if (flags & CWRAP_EXTEND) {
String *code = Getattr(n,"code");
if (code) {
String *tmp = NewStringf("%s(%s)", mangled, ParmList_str(parms));
String *s = SwigType_str(ty,tmp);
Delete(tmp);
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", Swig_cresult(ty,"result",Swig_cfunction_call(mangled,parms)));
} else {
Setattr(n,"wrap:action", Swig_cresult(ty,"result",Swig_cmemberget_call(name,type,self)));
}
Setattr(n,"type",ty);
Setattr(n,"parms", parms);
Delete(parms);
Delete(ty);
Delete(membername);
Delete(mangled);
return SWIG_OK;
}
void
SwigType_add_function(SwigType *t, ParmList *parms) {
String *pstr;
Parm *p;
Insert(t,0,").");
pstr = NewString("f(");
p = parms;
for (p = parms; p; p = nextSibling(p)) {
if (p != parms) Putc(',',pstr);
Printv(pstr, Getattr(p,"type"), NIL);
}
Insert(t,0,pstr);
Delete(pstr);
}
int
Swig_DestructorToFunction(Node *n, String *classname, int cplus, int flags)
{
SwigType *type;
Parm *p;
type = NewString(classname);
SwigType_add_pointer(type);
p = NewParm(type,"self");
Delete(type);
type = NewString("void");
if (flags & CWRAP_EXTEND) {
String *membername, *mangled, *code;
membername = Swig_name_destroy(classname);
mangled = Swig_name_mangle(membername);
code = Getattr(n,"code");
if (code) {
String *s = NewStringf("void %s(%s)", mangled, ParmList_str(p));
Printv(s,code,"\n",NIL);
Setattr(n,"wrap:code",s);
Delete(s);
}
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cfunction_call(mangled,p)));
Delete(membername);
Delete(mangled);
} else {
if (cplus) {
String* action = NewString("");
Printf(action, "%s;\n", Swig_cppdestructor_call());
Setattr(n,"wrap:action", action);
} else {
Setattr(n,"wrap:action", NewStringf("%s;\n", Swig_cdestructor_call()));
}
}
Setattr(n,"type",type);
Setattr(n,"parms", p);
Delete(type);
Delete(p);
return SWIG_OK;
}
String *Swig_strip_c_comments(const String *s) {
const char *c = Char(s);
const char *comment_begin = 0;
const char *comment_end = 0;
String *stripped = 0;
while (*c) {
if (!comment_begin && *c == '/') {
++c;
if (!*c)
break;
if (*c == '*')
comment_begin = c-1;
} else if (comment_begin && !comment_end && *c == '*') {
++c;
if (*c == '/') {
comment_end = c;
break;
}
}
++c;
}
if (comment_begin && comment_end) {
int size = (int)(comment_begin - Char(s));
String *stripmore = 0;
stripped = NewStringWithSize(s, size);
Printv(stripped, comment_end + 1, NIL);
do {
stripmore = Swig_strip_c_comments(stripped);
if (stripmore) {
Delete(stripped);
stripped = stripmore;
}
} while (stripmore);
}
return stripped;
}
String *Swig_cresult(SwigType *t, const String_or_char *name, const String_or_char *decl) {
String *fcall;
fcall = NewString("");
switch(SwigType_type(t)) {
case T_VOID:
break;
case T_REFERENCE:
Printf(fcall,"{\n");
Printf(fcall,"%s = ", SwigType_str(t,"_result_ref"));
break;
case T_USER:
Printf(fcall,"%s = ", name);
break;
default:
/* Normal return value */
Printf(fcall,"%s = (%s)", name, SwigType_lstr(t,0));
break;
}
/* Now print out function call */
Printv(fcall,decl,NIL);
/* A sick hack */
{
char *c = Char(decl) + Len(decl) - 1;
if (!((*c == ';') || (*c == '}')))
Printf(fcall, ";");
}
Printf(fcall,"\n");
if (SwigType_type(t) == T_REFERENCE) {
Printf(fcall,"%s = (%s) &_result_ref;\n", name, SwigType_lstr(t,0));
Printf(fcall,"}\n");
}
return fcall;
}
int Swig_MethodToFunction(Node *n, String *classname, int flags, SwigType *director_type, int is_director) {
String *name, *qualifier;
ParmList *parms;
SwigType *type;
Parm *p;
String *self = 0;
/* If smart pointer, change self dereferencing */
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
/* If node is a member template expansion, we don't allow added code */
if (Getattr(n, k_templatetype))
flags &= ~(CWRAP_EXTEND);
name = Getattr(n, k_name);
qualifier = Getattr(n, k_qualifier);
parms = CopyParmList(nonvoid_parms(Getattr(n, k_parms)));
type = NewString(classname);
if (qualifier) {
SwigType_push(type, qualifier);
}
SwigType_add_pointer(type);
p = NewParm(type, k_self);
Setattr(p, k_self, "1");
Setattr(p, k_hidden, "1");
/*
Disable the 'this' ownership in 'self' to manage inplace
operations like:
A& A::operator+=(int i) { ...; return *this;}
Here the 'self' parameter ownership needs to be disabled since
there could be two objects sharing the same 'this' pointer: the
input and the result one. And worse, the pointer could be deleted
in one of the objects (input), leaving the other (output) with
just a seg. fault to happen.
To avoid the previous problem, use
%feature("self:disown") *::operator+=;
%feature("new") *::operator+=;
These two lines just transfer the ownership of the 'this' pointer
from the input to the output wrapping object.
This happens in python, but may also happens in other target
languages.
*/
if (GetFlag(n, "feature:self:disown")) {
Setattr(p, k_wrapdisown, "1");
}
set_nextSibling(p, parms);
Delete(type);
/* Generate action code for the access */
if (!(flags & CWRAP_EXTEND)) {
String *explicit_qualifier = 0;
String *call = 0;
String *cres = 0;
String *explicitcall_name = 0;
int pure_virtual = !(Cmp(Getattr(n, k_storage), "virtual")) && !(Cmp(Getattr(n, k_value), "0"));
/* Call the explicit method rather than allow for a polymorphic call */
if ((flags & CWRAP_DIRECTOR_TWO_CALLS) || (flags & CWRAP_DIRECTOR_ONE_CALL)) {
String *access = Getattr(n, "access");
if (access && (Cmp(access, "protected") == 0)) {
/* If protected access (can only be if a director method) then call the extra public accessor method (language module must provide this) */
String *explicit_qualifier_tmp = SwigType_namestr(Getattr(Getattr(parentNode(n), "typescope"), k_qname));
explicitcall_name = NewStringf("%sSwigPublic", name);
explicit_qualifier = NewStringf("SwigDirector_%s", explicit_qualifier_tmp);
Delete(explicit_qualifier_tmp);
} else {
explicit_qualifier = SwigType_namestr(Getattr(Getattr(parentNode(n), "typescope"), k_qname));
}
}
call = Swig_cmethod_call(explicitcall_name ? explicitcall_name : name, p, self, explicit_qualifier, director_type);
cres = Swig_cresult(Getattr(n, k_type), k_result, call);
if (pure_virtual && is_director && (flags & CWRAP_DIRECTOR_TWO_CALLS)) {
String *qualifier = SwigType_namestr(Getattr(Getattr(parentNode(n), "typescope"), k_qname));
Delete(cres);
cres = NewStringf("Swig::DirectorPureVirtualException::raise(\"%s::%s\");", qualifier, name);
Delete(qualifier);
}
if (flags & CWRAP_DIRECTOR_TWO_CALLS) {
/* Create two method calls, one to call the explicit method, the other a normal polymorphic function call */
String *cres_both_calls = NewStringf("");
String *call_extra = Swig_cmethod_call(name, p, self, 0, director_type);
String *cres_extra = Swig_cresult(Getattr(n, k_type), k_result, call_extra);
Printv(cres_both_calls, "if (upcall) {\n", cres, "\n", "} else {", cres_extra, "\n}", NIL);
Setattr(n, k_wrapaction, cres_both_calls);
Delete(cres_extra);
Delete(call_extra);
Delete(cres_both_calls);
} else {
Setattr(n, k_wrapaction, cres);
}
Delete(explicitcall_name);
Delete(call);
Delete(cres);
Delete(explicit_qualifier);
} else {
/* Methods with default arguments are wrapped with additional methods for each default argument,
* however, only one extra %extend method is generated. */
String *defaultargs = Getattr(n, k_defaultargs);
String *code = Getattr(n, k_code);
String *cname = Getattr(n, k_classname) ? Getattr(n, k_classname) : classname;
String *membername = Swig_name_member(cname, name);
String *mangled = Swig_name_mangle(membername);
int is_smart_pointer = flags & CWRAP_SMART_POINTER;
type = Getattr(n, k_type);
/* Check if the method is overloaded. If so, and it has code attached, we append an extra suffix
to avoid a name-clash in the generated wrappers. This allows overloaded methods to be defined
in C. */
if (Getattr(n, k_symoverloaded) && code) {
Append(mangled, Getattr(defaultargs ? defaultargs : n, k_symovername));
}
/* See if there is any code that we need to emit */
if (!defaultargs && code && !is_smart_pointer) {
Swig_add_extension_code(n, mangled, p, type, code, cparse_cplusplus, k_self);
}
if (is_smart_pointer) {
int i = 0;
Parm *pp = p;
String *func = NewStringf("%s(", mangled);
String *cres;
if (Cmp(Getattr(n, k_storage), k_static) != 0) {
String *pname = Swig_cparm_name(pp, i);
String *ctname = SwigType_namestr(cname);
String *fadd = NewStringf("(%s*)(%s)->operator ->()", ctname, pname);
Append(func, fadd);
Delete(ctname);
Delete(fadd);
Delete(pname);
pp = nextSibling(pp);
if (pp)
Append(func, ",");
} else {
pp = nextSibling(pp);
}
++i;
while (pp) {
SwigType *pt = Getattr(pp, k_type);
if ((SwigType_type(pt) != T_VOID)) {
String *pname = Swig_cparm_name(pp, i++);
String *rcaststr = SwigType_rcaststr(pt, pname);
Append(func, rcaststr);
Delete(rcaststr);
Delete(pname);
pp = nextSibling(pp);
if (pp)
Append(func, ",");
}
}
Append(func, ")");
cres = Swig_cresult(Getattr(n, k_type), k_result, func);
Setattr(n, k_wrapaction, cres);
Delete(cres);
} else {
String *call = Swig_cfunction_call(mangled, p);
String *cres = Swig_cresult(Getattr(n, k_type), k_result, call);
Setattr(n, k_wrapaction, cres);
Delete(call);
Delete(cres);
}
Delete(membername);
Delete(mangled);
}
Setattr(n, k_parms, p);
Delete(p);
Delete(self);
Delete(parms);
return SWIG_OK;
}
static String *Swig_cmethod_call(String_or_char *name, ParmList *parms, String_or_char *self, String *explicit_qualifier, SwigType *director_type) {
String *func, *nname;
int i = 0;
Parm *p = parms;
SwigType *pt;
int comma = 0;
func = NewStringEmpty();
if (!p)
return func;
if (!self)
self = (char *) "(this)->";
Append(func, self);
if (SwigType_istemplate(name) && (strncmp(Char(name), "operator ", 9) == 0)) {
/* fix for template + operators and compilers like gcc 3.3.5 */
String *tprefix = SwigType_templateprefix(name);
nname = tprefix;
} else {
nname = SwigType_namestr(name);
}
if (director_type) {
const char *pname = "darg";
String *rcaststr = SwigType_rcaststr(director_type, pname);
Replaceall(func, "this", rcaststr);
Delete(rcaststr);
} else {
pt = Getattr(p, k_type);
/* If the method is invoked through a dereferenced pointer, we don't add any casts
(needed for smart pointers). Otherwise, we cast to the appropriate type */
if (Strstr(func, "*this")) {
String *pname = Swig_cparm_name(p, 0);
Replaceall(func, "this", pname);
Delete(pname);
} else {
String *pname = Swig_cparm_name(p, 0);
String *rcaststr = SwigType_rcaststr(pt, pname);
Replaceall(func, "this", rcaststr);
Delete(rcaststr);
Delete(pname);
}
/*
SWIGTEMPLATEDESIMBUAGATOR is compiler dependent (swiglabels.swg),
- SUN Studio 9 requires 'template',
- gcc-3.4 forbids the use of 'template' (correctly implementing the ISO C++ standard)
the others don't seem to care,
*/
if (SwigType_istemplate(name))
Printf(func, "SWIGTEMPLATEDISAMBIGUATOR ");
if (explicit_qualifier) {
Printv(func, explicit_qualifier, "::", NIL);
}
}
Printf(func, "%s(", nname);
i++;
p = nextSibling(p);
while (p) {
pt = Getattr(p, k_type);
if ((SwigType_type(pt) != T_VOID)) {
String *pname = Swig_cparm_name(p, i);
String *rcaststr = SwigType_rcaststr(pt, pname);
if (comma)
Append(func, ",");
Append(func, rcaststr);
Delete(rcaststr);
Delete(pname);
comma = 1;
i++;
}
p = nextSibling(p);
}
Append(func, ")");
Delete(nname);
return func;
}
void SwigType_typename_replace(SwigType *t, String *pat, String *rep) {
String *nt;
int i, ilen;
List *elem;
if (!Strstr(t, pat))
return;
if (Equal(t, pat)) {
Replace(t, pat, rep, DOH_REPLACE_ANY);
return;
}
nt = NewStringEmpty();
elem = SwigType_split(t);
ilen = Len(elem);
for (i = 0; i < ilen; i++) {
String *e = Getitem(elem, i);
if (SwigType_issimple(e)) {
if (Equal(e, pat)) {
/* Replaces a type of the form 'pat' with 'rep<args>' */
Replace(e, pat, rep, DOH_REPLACE_ANY);
} else if (SwigType_istemplate(e)) {
/* Replaces a type of the form 'pat<args>' with 'rep' */
if (Equal(e, pat)) {
String *repbase = SwigType_templateprefix(rep);
Replace(e, pat, repbase, DOH_REPLACE_ID | DOH_REPLACE_FIRST);
Delete(repbase);
}
{
String *tsuffix;
List *tparms = SwigType_parmlist(e);
int j, jlen;
String *nt = SwigType_templateprefix(e);
Append(nt, "<(");
jlen = Len(tparms);
for (j = 0; j < jlen; j++) {
SwigType_typename_replace(Getitem(tparms, j), pat, rep);
Append(nt, Getitem(tparms, j));
if (j < (jlen - 1))
Putc(',', nt);
}
tsuffix = SwigType_templatesuffix(e);
Printf(nt, ")>%s", tsuffix);
Delete(tsuffix);
Clear(e);
Append(e, nt);
Delete(nt);
Delete(tparms);
}
} else if (Swig_scopename_check(e)) {
String *first, *rest;
first = Swig_scopename_first(e);
rest = Swig_scopename_suffix(e);
SwigType_typename_replace(rest, pat, rep);
SwigType_typename_replace(first, pat, rep);
Clear(e);
Printv(e, first, "::", rest, NIL);
Delete(first);
Delete(rest);
}
} else if (SwigType_isfunction(e)) {
int j, jlen;
List *fparms = SwigType_parmlist(e);
Clear(e);
Append(e, "f(");
jlen = Len(fparms);
for (j = 0; j < jlen; j++) {
SwigType_typename_replace(Getitem(fparms, j), pat, rep);
Append(e, Getitem(fparms, j));
if (j < (jlen - 1))
Putc(',', e);
}
Append(e, ").");
Delete(fparms);
} else if (SwigType_isarray(e)) {
Replace(e, pat, rep, DOH_REPLACE_ID);
}
Append(nt, e);
}
Clear(t);
Append(t, nt);
Delete(nt);
Delete(elem);
}
int
Swig_ConstructorToFunction(Node *n, String *classname,
String *none_comparison, String *director_ctor, int cplus, int flags)
{
ParmList *parms;
Parm *prefix_args;
Parm *postfix_args;
Parm *p;
ParmList *directorparms;
SwigType *type;
String *membername;
String *mangled;
Node *classNode;
int use_director;
classNode = Swig_methodclass(n);
use_director = Swig_directorclass(n);
membername = Swig_name_construct(classname);
mangled = Swig_name_mangle(membername);
parms = CopyParmList(nonvoid_parms(Getattr(n,"parms")));
/* Prepend the list of prefix_args (if any) */
prefix_args = Getattr(n,"director:prefix_args");
if (prefix_args != NIL) {
Parm *p2, *p3;
directorparms = CopyParmList(prefix_args);
for (p = directorparms; nextSibling(p); p = nextSibling(p));
for (p2 = parms; p2; p2 = nextSibling(p2)) {
p3 = CopyParm(p2);
set_nextSibling(p, p3);
p = p3;
}
} else
directorparms = parms;
postfix_args = Getattr(n,"director:postfix_args");
if (postfix_args != NIL) {
Parm *p2, *p3, *p4;
if (prefix_args == NIL) /* no prefix args from above. */
directorparms = CopyParmList(parms);
if (directorparms != NIL) {
p2 = directorparms;
for ( ; nextSibling(p2); p2 = nextSibling(p2));
for (p3 = postfix_args; p3; p3 = nextSibling(p3)) {
p4 = CopyParm(p3);
set_nextSibling(p2, p4);
p2 = p4;
}
} else
directorparms = CopyParmList(postfix_args);
}
type = NewString(classname);
SwigType_add_pointer(type);
if (flags & CWRAP_EXTEND) {
String *code = Getattr(n,"code");
if (code) {
String *wrap, *s;
if (Getattr(n,"sym:overloaded") && code) {
Append(mangled,Getattr(n,"sym:overname"));
}
s = NewStringf("%s(%s)", mangled, ParmList_str(parms));
wrap = SwigType_str(type,s);
Delete(s);
Printv(wrap,code,"\n",NIL);
Setattr(n,"wrap:code",wrap);
Delete(wrap);
}
Setattr(n,"wrap:action", Swig_cresult(type,"result", Swig_cfunction_call(mangled,parms)));
} else {
if (cplus) {
/* if a C++ director class exists, create it rather than the original class */
if (use_director) {
int abstract = Getattr(n, "abstract") != 0;
Node *parent = Swig_methodclass(n);
String *name = Getattr(parent, "sym:name");
String* directorname = NewStringf("SwigDirector_%s", name);
String* action = NewString("");
String* tmp_none_comparison = Copy(none_comparison);
String* director_call;
String* nodirector_call;
Replaceall( tmp_none_comparison, "$arg", "arg1" );
director_call = Swig_cppconstructor_director_call(directorname, directorparms);
nodirector_call = Swig_cppconstructor_nodirector_call(classname, parms);
if (abstract) {
/* whether or not the abstract class has been subclassed in python,
* create a director instance (there's no way to create a normal
* instance). if any of the pure virtual methods haven't been
* implemented in the target language, calls to those methods will
* generate Swig::DirectorPureVirtualException exceptions.
*/
Printv(action, Swig_cresult(type, "result", director_call), NIL);
} else {
/* (scottm): The code for creating a new director is now a string
template that gets passed in via the director_ctor argument.
$comparison : an 'if' comparison from none_comparison
$director_new: Call new for director class
$nondirector_new: Call new for non-director class
*/
Printv(action, director_ctor, NIL);
Replaceall( action, "$comparison", tmp_none_comparison);
Replaceall( action, "$director_new",
Swig_cresult(type, "result", director_call) );
Replaceall( action, "$nondirector_new",
Swig_cresult(type, "result", nodirector_call) );
}
Setattr(n, "wrap:action", action);
Delete(tmp_none_comparison);
Delete(action);
Delete(directorname);
} else {
Setattr(n,"wrap:action", Swig_cresult(type,"result", Swig_cppconstructor_call(classname,parms)));
}
} else {
Setattr(n,"wrap:action", Swig_cresult(type,"result", Swig_cconstructor_call(classname)));
}
}
Setattr(n,"type",type);
Setattr(n,"parms", parms);
Delete(type);
if (directorparms != parms)
Delete(directorparms);
Delete(parms);
Delete(mangled);
Delete(membername);
return SWIG_OK;
}
int
Swig_MethodToFunction(Node *n, String *classname, int flags) {
String *name, *qualifier;
ParmList *parms;
SwigType *type;
Parm *p;
String *self = 0;
/* If smart pointer, change self derefencing */
if (flags & CWRAP_SMART_POINTER) {
self = NewString("(*this)->");
}
/* If node is a member template expansion, we don't allow added code */
if (Getattr(n,"templatetype")) flags &= ~(CWRAP_EXTEND);
name = Getattr(n,"name");
qualifier = Getattr(n,"qualifier");
parms = CopyParmList(nonvoid_parms(Getattr(n,"parms")));
type = NewString(classname);
if (qualifier) {
SwigType_push(type,qualifier);
}
SwigType_add_pointer(type);
p = NewParm(type,"self");
Setattr(p,"hidden","1");
set_nextSibling(p,parms);
Delete(type);
/* Generate action code for the access */
if (!(flags & CWRAP_EXTEND)) {
Setattr(n,"wrap:action", Swig_cresult(Getattr(n,"type"),"result", Swig_cmethod_call(name,p,self)));
} else {
String *code;
String *mangled;
String *membername = Swig_name_member(classname, name);
mangled = Swig_name_mangle(membername);
code = Getattr(n,"code");
type = Getattr(n,"type");
/* Check if the method is overloaded. If so, and it has code attached, we append an extra suffix
to avoid a name-clash in the generated wrappers. This allows overloaded methods to be defined
in C. */
if (Getattr(n,"sym:overloaded") && code) {
Append(mangled,Getattr(n,"sym:overname"));
}
Setattr(n,"wrap:action", Swig_cresult(Getattr(n,"type"),"result", Swig_cfunction_call(mangled,p)));
/* See if there is any code that we need to emit */
if (code) {
String *body;
String *tmp = NewStringf("%s(%s)", mangled, ParmList_str(p));
body = SwigType_str(type,tmp);
Delete(tmp);
Printv(body,code,"\n",NIL);
Setattr(n,"wrap:code",body);
}
Delete(membername);
Delete(mangled);
}
Setattr(n,"parms",p);
Delete(p);
Delete(self);
return SWIG_OK;
}
