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

Added cwrap.c file that contains a variety of wrapper function support code

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@600 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-07-24 03:54:02 +00:00
commit ccbe7d8213
8 changed files with 972 additions and 215 deletions
Download patch file Download diff file Expand all files Collapse all files

674
SWIG/Source/Swig/cwrap.c
View file

@ -27,8 +27,12 @@ char *
Swig_cparm_name(Parm *p, int i) {
static char name[256];
sprintf(name,"arg%d",i);
Parm_Setlname(p,name);
return Parm_Getlname(p);
if (p) {
Parm_Setlname(p,name);
return Parm_Getlname(p);
} else {
return name;
}
}
/* -----------------------------------------------------------------------------
@ -174,10 +178,7 @@ int Swig_cargs(Wrapper *w, ParmList *l) {
* ----------------------------------------------------------------------------- */
void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
int i;
Parm *p;
DOHString *fcall;
char *tm;
fcall = NewString("");
if ((t->type != T_VOID) || (t->is_pointer)) {
@ -224,10 +225,7 @@ void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or
* ----------------------------------------------------------------------------- */
void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
int i;
Parm *p;
DOHString *fcall;
char *tm;
fcall = NewString("");
if ((t->type != T_VOID) || (t->is_pointer)) {
@ -240,7 +238,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
} else {
/* Normal return value */
Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0);
Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0);
}
}
}
@ -264,7 +262,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
}
/* -----------------------------------------------------------------------------
* Swig_cfunction()
* Swig_cfunction_call()
*
* Creates a string that calls a C function using the local variable rules
* defined above.
@ -274,7 +272,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
* ----------------------------------------------------------------------------- */
char *
Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
int i = 0;
Parm *p;
@ -299,7 +297,7 @@ Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
}
/* -----------------------------------------------------------------------------
* Swig_cmethod()
* Swig_cmethod_call()
*
* Generates a string that calls a C++ method from a list of parameters.
*
@ -308,7 +306,7 @@ Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
* ----------------------------------------------------------------------------- */
char *
Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
int i = 0;
Parm *p;
@ -336,7 +334,100 @@ Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
}
/* -----------------------------------------------------------------------------
* Swig_cmember_set()
* Swig_cconstructor_call()
*
* Creates a string that calls a C constructor function.
*
* (name *) calloc(1,sizeof(name));
* ----------------------------------------------------------------------------- */
char *
Swig_cconstructor_call(DOHString_or_char *name) {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
Printf(func,"(%s *) calloc(1, sizeof(%s))", name, name);
return Char(func);
}
/* -----------------------------------------------------------------------------
* Swig_cppconstructor_call()
*
* Creates a string that calls a C function using the local variable rules
* defined above.
*
* name(arg0, arg1, arg2, ... argn)
*
* ----------------------------------------------------------------------------- */
char *
Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
int i = 0;
Parm *p;
DataType *pt;
if (!func) func = NewString("");
Clear(func);
Printf(func,"new %s(", name);
p = ParmList_first(parms);
while (p) {
pt = Parm_Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
i++;
p = ParmList_next(parms);
if (p)
Printf(func,",");
}
Printf(func,")");
return Char(func);
}
/* -----------------------------------------------------------------------------
* Swig_cdestructor_call()
*
* Creates a string that calls a C constructor function.
*
* free((char *) arg0);
* ----------------------------------------------------------------------------- */
char *
Swig_cdestructor_call() {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
Printf(func,"free((char *) %s)", Swig_cparm_name(0,0));
return Char(func);
}
/* -----------------------------------------------------------------------------
* Swig_cppdestructor_call()
*
* Creates a string that calls a C constructor function.
*
* delete arg0;
* ----------------------------------------------------------------------------- */
char *
Swig_cppdestructor_call() {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
Printf(func,"delete %s", Swig_cparm_name(0,0));
return Char(func);
}
/* -----------------------------------------------------------------------------
* Swig_cmemberset_call()
*
* Generates a string that sets the name of a member in a C++ class or C struct.
*
@ -345,31 +436,25 @@ Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
* ----------------------------------------------------------------------------- */
char *
Swig_cmember_set(DOHString_or_char *name, ParmList *parms) {
Swig_cmemberset_call(DOHString_or_char *name, DataType *type) {
static DOH *func = 0;
Parm *p;
DataType *pt;
if (!func) func = NewString("");
Clear(func);
if (ParmList_numarg(parms) != 2) {
printf("Swig_cmember_set called with wrong # args!\n");
abort();
if ((type->type == T_USER) && (type->is_pointer == 0)) {
Printf(func,"%s %s->%s; ", Swig_clocal_assign(type,""), Swig_cparm_name(0,0), name);
} else {
Printf(func,"%s ", Swig_clocal_assign(type,""));
}
p = ParmList_first(parms);
Printf(func,"(%s->%s = ", Swig_cparm_name(p,0), name);
p = ParmList_next(parms);
pt = Parm_Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,1)));
Printf(func,")");
Printf(func,"(%s->%s = ", Swig_cparm_name(0,0), name);
Printf(func,"%s)", Swig_clocal_deref(type, Swig_cparm_name(0,1)));
return Char(func);
}
/* -----------------------------------------------------------------------------
* Swig_cmember_get()
* Swig_cmemberget_call()
*
* Generates a string that sets the name of a member in a C++ class or C struct.
*
@ -378,28 +463,535 @@ Swig_cmember_set(DOHString_or_char *name, ParmList *parms) {
* ----------------------------------------------------------------------------- */
char *
Swig_cmember_get(DOHString_or_char *name, ParmList *parms) {
Swig_cmemberget_call(DOHString_or_char *name, DataType *t) {
static DOH *func = 0;
Parm *p;
DataType *pt;
if (!func) func = NewString("");
Clear(func);
if (ParmList_numarg(parms) != 1) {
printf("Swig_cmember_get called with wrong # args!\n");
abort();
}
p = ParmList_first(parms);
Printf(func,"(%s->%s)", Swig_cparm_name(p,0), name);
Printf(func,"%s (%s->%s)", Swig_clocal_assign(t,""),Swig_cparm_name(0,0), name);
return Char(func);
}
static void fix_parm_names(ParmList *l) {
int i = 0;
Parm *p;
p = ParmList_first(l);
while (p) {
if (!Parm_Getname(p)) {
char temp[64];
sprintf(temp,"arg%d",i);
Parm_Setname(p,temp);
}
i++;
p = ParmList_next(l);
}
}
/* -----------------------------------------------------------------------------
* Swig_cfunction_wrapper()
*
* This function creates a C wrapper around a C++ method. Returns a Wrapper
* object containing the code, parameters, and so forth.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cfunction_wrapper(DOHString_or_char *funcname,
DataType *rtype,
ParmList *parms,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,funcname);
l = CopyParmList(parms);
fix_parm_names(l);
Printf(w->def,"%s %s(%s)", DataType_str(rtype,0), funcname, ParmList_str(l));
if (code) {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,rtype);
Wrapper_Setparms(w,l);
DelParmList(l);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cmethod_wrapper()
*
* This function creates a C wrapper around a C++ method. Returns a Wrapper
* object containing the code, parameters, and so forth.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmethod_wrapper(DOHString_or_char *classname,
DOHString_or_char *methodname,
DataType *rtype,
ParmList *parms,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_member(classname, methodname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_insert(l,p,0);
DelDataType(t);
DelParm(p);
fix_parm_names(l);
Printf(w->def,"%s %s(%s)", DataType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
if ((rtype->type != T_VOID) || (rtype->is_pointer)) {
Printf(w->code,"return ");
}
Printf(w->code,"self->%s(", methodname);
p = ParmList_first(l);
p = ParmList_next(l);
while (p) {
Printf(w->code,"%s", Parm_Getname(p));
p = ParmList_next(l);
if (p)
Printf(w->code,",");
}
Printf(w->code,");\n");
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,rtype);
Wrapper_Setparms(w,l);
DelParmList(l);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cconstructor_wrapper()
*
* This function creates a C wrapper for a C constructor function.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cconstructor_wrapper(DOHString_or_char *classname,
ParmList *parms,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_construct(classname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
sprintf(t->name,classname);
t->is_pointer++;
/* Patch up the argument names */
fix_parm_names(l);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_construct(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", DataType_str(t,0), classname);
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(t);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cppconstructor_wrapper()
*
* This function creates a C wrapper for a C++ constructor function.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cppconstructor_wrapper(DOHString_or_char *classname,
ParmList *parms,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
Parm *p;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_construct(classname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
sprintf(t->name,classname);
t->is_pointer++;
/* Patch up the argument names */
fix_parm_names(l);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_construct(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"return new %s", DataType_str(t,0));
p = ParmList_first(l);
if (p) {
Printf(w->code,"(");
while (p) {
Printf(w->code,"%s", Parm_Getname(p));
p = ParmList_next(l);
if (p)
Printf(w->code,",");
}
Printf(w->code,")");
}
Printf(w->code,";\n");
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(t);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cdestructor_wrapper()
*
* This function creates a C wrapper for a C destructor.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
Parm *p;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_destroy(classname));
l = NewParmList();
t = NewDataType(T_USER);
sprintf(t->name,classname);
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelParm(p);
DelDataType(t);
t = NewDataType(T_VOID);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"free((char *) self);\n");
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(t);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cppdestructor_wrapper()
*
* This function creates a C wrapper for a C++ destructor.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cppdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
Parm *p;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_destroy(classname));
l = NewParmList();
t = NewDataType(T_USER);
sprintf(t->name,classname);
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelParm(p);
DelDataType(t);
t = NewDataType(T_VOID);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"delete self;\n");
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(t);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cmemberset_wrapper()
*
* This function creates a C wrapper for setting a C++ structure member.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmemberset_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
DataType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_member(classname, Swig_name_set(membername)));
l = NewParmList();
t = NewDataType(T_USER);
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelDataType(t);
DelParm(p);
lt = Swig_clocal_type(type);
p = NewParm(lt,"value");
ParmList_append(l,p);
DelParm(p);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"self->%s = %s;\n", membername, Swig_clocal_deref(lt,"value"));
Printf(w->code,"return %s self->%s;\n", Swig_clocal_assign(lt,""), membername);
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(lt);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cmemberget_wrapper()
*
* This function creates a C wrapper for getting a structure member
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmemberget_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
DataType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_member(classname, Swig_name_get(membername)));
l = NewParmList();
t = NewDataType(T_USER);
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelDataType(t);
DelParm(p);
lt = Swig_clocal_type(type);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"return %s self->%s;", Swig_clocal_assign(lt,""), membername);
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(lt);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cvarset_wrapper()
*
* This function creates a C wrapper for setting a global variable.
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cvarset_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_set(varname));
l = NewParmList();
lt = Swig_clocal_type(type);
p = NewParm(lt,"value");
ParmList_append(l,p);
DelParm(p);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"%s = %s;\n", varname, Swig_clocal_deref(lt,"value"));
Printf(w->code,"return %s;\n", Swig_clocal_assign(lt,varname));
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
Replace(w->code,"$target",varname, DOH_REPLACE_ANY);
Replace(w->code,"$source","value", DOH_REPLACE_ANY);
Replace(w->code,"$ltype", DataType_str(lt,""), DOH_REPLACE_ANY);
Replace(w->code,"$rtype", DataType_str(type,""), DOH_REPLACE_ANY);
}
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(lt);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cvarget_wrapper()
*
* This function creates a C wrapper for getting a structure member
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cvarget_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w, Swig_name_get(varname));
l = NewParmList();
lt = Swig_clocal_type(type);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->def," {\n");
Printf(w->code,"return %s;", Swig_clocal_assign(type,varname));
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
DelDataType(lt);
return w;
}

6
SWIG/Source/Swig/map.c
View file

@ -10,6 +10,8 @@
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "swig.h"
/* -----------------------------------------------------------------------------
@ -223,7 +225,7 @@ Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename, DOHHash *parms, in
related to array indices */
int ndim;
int i, j, k, n;
int i, j, n;
int ncheck;
DOHString *ntype;
@ -306,7 +308,7 @@ Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename, DOHHash *parms, in
} else {
/* If there is no match at all. I guess we can check for a default type */
DOH *rs;
DOHString *key, *name;
DOHString *key;
DOHString *dty = SwigType_default(Getattr(parms,"type"));
key = NewStringf("-%s",dty);

27
SWIG/Source/Swig/naming.c
View file

@ -82,6 +82,7 @@ char *Swig_name_wrapper(DOHString_or_char *fname) {
char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
static DOHString *r = 0;
DOHString *f;
char *cname, *c;
if (!r) r = NewString("");
if (!naming_hash) naming_hash = NewHash();
@ -92,7 +93,10 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
} else {
Append(r,f);
}
Replace(r,"%c",classname, DOH_REPLACE_ANY);
cname = Char(classname);
c = strchr(cname, ' ');
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
Replace(r,"%m",mname, DOH_REPLACE_ANY);
return Char(r);
}
@ -152,7 +156,7 @@ char *Swig_name_set(DOHString_or_char *vname) {
char *Swig_name_construct(DOHString_or_char *classname) {
static DOHString *r = 0;
DOHString *f;
char *cname, *c;
if (!r) r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
@ -162,7 +166,12 @@ char *Swig_name_construct(DOHString_or_char *classname) {
} else {
Append(r,f);
}
Replace(r,"%c",classname, DOH_REPLACE_ANY);
cname = Char(classname);
c = strchr(cname, ' ');
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
return Char(r);
}
@ -176,7 +185,7 @@ char *Swig_name_construct(DOHString_or_char *classname) {
char *Swig_name_destroy(DOHString_or_char *classname) {
static DOHString *r = 0;
DOHString *f;
char *cname, *c;
if (!r) r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
@ -186,6 +195,14 @@ char *Swig_name_destroy(DOHString_or_char *classname) {
} else {
Append(r,f);
}
Replace(r,"%c",classname, DOH_REPLACE_ANY);
cname = Char(classname);
c = strchr(cname, ' ');
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
return Char(r);
}

41
SWIG/Source/Swig/oldparms.c
View file

@ -36,7 +36,7 @@ Parm *NewParm(DataType *type, char *n) {
p->_name = Swig_copy_string(n);
p->_lname = 0;
p->_defvalue = 0;
p->ignore = 0;
p->_ignore = 0;
return p;
}
@ -50,7 +50,7 @@ Parm *CopyParm(Parm *p) {
np->_name = Swig_copy_string(p->_name);
np->_defvalue = Swig_copy_string(p->_defvalue);
np->_lname = Swig_copy_string(p->_lname);
np->ignore = p->ignore;
np->_ignore = p->_ignore;
return np;
}
@ -102,6 +102,14 @@ char *Parm_Getvalue(Parm *p) {
return p->_defvalue;
}
int Parm_Getignore(Parm *p) {
return p->_ignore;
}
void Parm_Setignore(Parm *p, int i) {
p->_ignore = i;
}
/* ------------------------------------------------------------------
* NewParmList()
* ------------------------------------------------------------------ */
@ -259,7 +267,7 @@ int ParmList_numarg(ParmList *l) {
int n = 0;
int i;
for (i = 0; i < l->nparms; i++) {
if (!l->parms[i]->ignore)
if (!Parm_Getignore(l->parms[i]))
n++;
}
return n;
@ -293,7 +301,6 @@ Parm * ParmList_next(ParmList *l) {
void ParmList_print_types(ParmList *l, DOHFile *f) {
int is_pointer;
int pn;
DataType *t;
pn = 0;
@ -313,7 +320,6 @@ void ParmList_print_types(ParmList *l, DOHFile *f) {
* ---------------------------------------------------------------------- */
void ParmList_print_args(ParmList *l, DOHFile *f) {
int is_pointer;
int pn;
DataType *t;
pn = 0;
@ -327,4 +333,29 @@ void ParmList_print_args(ParmList *l, DOHFile *f) {
}
/* ---------------------------------------------------------------------
* void ParmList_str()
*
* Generates a string of parameters
* ---------------------------------------------------------------------- */
char *ParmList_str(ParmList *l) {
static DOHString *out = 0;
int pn;
DataType *t;
if (!out) out = NewString("");
Clear(out);
pn = 0;
while(pn < l->nparms) {
t = Parm_Gettype(l->parms[pn]);
Printf(out,"%s", DataType_str(t,Parm_Getname(l->parms[pn])));
pn++;
if (pn < l->nparms)
Printf(out,",");
}
return Char(out);
}

13
SWIG/Source/Swig/oldtypes.c
View file

@ -28,19 +28,19 @@ DataType *NewDataType(int t) {
case T_BOOL:
strcpy(ty->name,"bool");
break;
case T_INT: case T_SINT:
case T_INT:
strcpy(ty->name,"int");
break;
case T_UINT:
strcpy(ty->name,"unsigned int");
break;
case T_SHORT: case T_SSHORT:
case T_SHORT:
strcpy(ty->name,"short");
break;
case T_USHORT:
strcpy(ty->name,"unsigned short");
break;
case T_LONG: case T_SLONG:
case T_LONG:
strcpy(ty->name,"long");
break;
case T_ULONG:
@ -130,13 +130,13 @@ void DataType_primitive(DataType *t) {
case T_BOOL:
strcpy(t->name,"bool");
break;
case T_INT: case T_SINT:
case T_INT:
strcpy(t->name,"int");
break;
case T_SHORT: case T_SSHORT:
case T_SHORT:
strcpy(t->name,"short");
break;
case T_LONG: case T_SLONG:
case T_LONG:
strcpy(t->name,"long");
break;
case T_CHAR:
@ -410,7 +410,6 @@ char *DataType_rcaststr(DataType *ty, DOHString_or_char *name) {
char *DataType_lcaststr(DataType *ty, DOHString_or_char *name) {
static char result[8][256];
static int ri = 0;
DataType *t = 0;
ri = ri % 8;
strcpy(result[ri],"");

8
SWIG/Source/Swig/stype.c
View file

@ -10,6 +10,8 @@
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "swig.h"
/* -----------------------------------------------------------------------------
@ -244,7 +246,6 @@ void SwigType_push(DOHString *t, DOHString *cons)
if (!cons) return;
if (!Len(cons)) return;
if (Len(t)) {
int len;
char *c = Char(cons);
if (c[strlen(c)-1] != '.')
Insert(t,0,".");
@ -534,10 +535,9 @@ DOHString *
SwigType_cstr(DOHString *s, DOHString_or_char *id)
{
DOHString *result;
DOHString *element, *nextelement;
DOHString *element = 0, *nextelement;
DOHList *elements;
int nelements, i;
char *c;
if (id) {
result = NewString(Char(id));
@ -616,7 +616,7 @@ static DOHHash *scopes[MAX_SCOPE]; /* List representing the current
static DOHString *scopenames[MAX_SCOPE]; /* Names of the various scopes */
static int scope_level = 0;
static init_scopes() {
static void init_scopes() {
if (type_scopes) return;
type_scopes = NewHash();
scopes[scope_level] = NewHash();

352
SWIG/Source/Swig/swig.h
View file

@ -22,6 +22,129 @@
#include "doh.h"
/* --- Legacy DataType interface. This is being replaced --- */
#define T_INT 1
#define T_SHORT 2
#define T_LONG 3
#define T_UINT 4
#define T_USHORT 5
#define T_ULONG 6
#define T_UCHAR 7
#define T_SCHAR 8
#define T_BOOL 9
#define T_DOUBLE 10
#define T_FLOAT 11
#define T_CHAR 12
#define T_USER 13
#define T_VOID 14
#define T_SYMBOL 98
#define T_ERROR 99
#define MAX_NAME 96
typedef struct DataType {
int type; /* SWIG Type code */
char name[MAX_NAME]; /* Name of type */
int is_pointer; /* Is this a pointer */
int implicit_ptr; /* Implicit ptr */
int is_reference; /* A C++ reference type */
int status; /* Is this datatype read-only? */
char *_qualifier; /* A qualifier string (ie. const). */
char *_arraystr; /* String containing array part */
int id; /* type identifier (unique for every type). */
} DataType;
extern DataType *NewDataType(int type);
extern DataType *CopyDataType(DataType *type);
extern void DelDataType(DataType *type);
/* -- New type interface -- */
extern char *DataType_str(DataType *, DOHString_or_char *name); /* Exact datatype */
extern char *DataType_lstr(DataType *, DOHString_or_char *name); /* Assignable datatype */
extern char *DataType_rcaststr(DataType *, DOHString_or_char *name); /* Cast from lstr to str */
extern char *DataType_lcaststr(DataType *, DOHString_or_char *name); /* Cast from str to lstr */
extern char *DataType_manglestr(DataType *t); /* Mangled type name */
extern DataType *DataType_ltype(DataType *); /* Create local type object */
/* -- Old type interface -- */
extern char *DataType_qualifier(DataType *);
extern void DataType_set_qualifier(DataType *, char *q);
extern char *DataType_arraystr(DataType *);
extern void DataType_set_arraystr(DataType *, char *a);
extern char *DataType_mangle_default(DataType *t); /* Default name mangler */
extern void DataType_primitive(DataType *);
extern void DataType_set_mangle(char *(*m)(DataType *));
extern int DataType_array_dimensions(DataType *);
extern char *DataType_get_dimension(DataType *, int);
/* Typedef support */
extern int DataType_typedef_add(DataType *, char *name, int mode);
extern void DataType_typedef_resolve(DataType *, int level);
extern void DataType_typedef_replace(DataType *);
extern int DataType_is_typedef(char *name);
extern void DataType_updatestatus(DataType *, int newstatus);
extern void DataType_init_typedef();
extern void DataType_merge_scope(DOHHash *h);
extern void DataType_new_scope(DOHHash *h);
extern void *DataType_collapse_scope(char *name);
extern void DataType_remember(DataType *);
extern void DataType_record_base(char *derived, char *base);
extern int type_id;
extern void emit_ptr_equivalence(DOHFile *tablef, DOHFile *initf);
extern void emit_type_table(DOHFile *out);
extern void typeeq_derived(char *n1, char *n2, char *cast);
extern void typeeq_addtypedef(char *name, char *eqname, DataType *t);
#define STAT_REPLACETYPE 2
/* --- Deprecated parameter list structure --- */
typedef struct Parm {
DataType *_type; /* Datatype of this parameter */
char *_name; /* Name of parameter (optional) */
char *_defvalue; /* Default value (as a string) */
char *_lname; /* Local name */
int _ignore; /* Ignore flag */
} Parm;
extern Parm *NewParm(DataType *type, char *n);
extern Parm *CopyParm(Parm *p);
extern void DelParm(Parm *p);
extern void Parm_Settype(Parm *p, DataType *t);
extern DataType *Parm_Gettype(Parm *p);
extern void Parm_Setname(Parm *p, char *name);
extern char *Parm_Getname(Parm *p);
extern void Parm_Setlname(Parm *p, char *lname);
extern char *Parm_Getlname(Parm *p);
extern void Parm_Setvalue(Parm *p, char *value);
extern char *Parm_Getvalue(Parm *p);
extern int Parm_Getignore(Parm *p);
extern void Parm_Setignore(Parm *p, int i);
typedef struct ParmList {
int maxparms; /* Max parms possible in current list */
Parm **parms; /* Pointer to parms array */
int current_parm; /* Internal state for get_first,get_next */
int nparms; /* Number of parms in list */
} ParmList;
extern ParmList *NewParmList();
extern ParmList *CopyParmList(ParmList *);
extern void DelParmList(ParmList *);
extern Parm *ParmList_get(ParmList *l, int pos);
extern void ParmList_append(ParmList *, Parm *);
extern void ParmList_insert(ParmList *, Parm *, int);
extern void ParmList_del(ParmList *, int);
extern int ParmList_numarg(ParmList *);
extern Parm *ParmList_first(ParmList *);
extern Parm *ParmList_next(ParmList *);
extern void ParmList_print_types(ParmList*,DOHFile *f);
extern void ParmList_print_args(ParmList *, DOHFile *f);
extern char *ParmList_str(ParmList *);
/* --- File interface --- */
extern void Swig_add_directory(const DOHString_or_char *dirname);
@ -170,20 +293,29 @@ extern DOH *Swig_prev(DOH *obj);
/* -- Wrapper function Object */
typedef struct {
DataType *_type;
ParmList *_parms;
DOHString *_name;
DOHHash *localh;
DOHString *def;
DOHString *locals;
DOHString *code;
} Wrapper;
extern Wrapper *NewWrapper();
extern void DelWrapper(Wrapper *w);
extern void Wrapper_print(Wrapper *w, DOHFile *f);
extern int Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl);
extern int Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...);
extern int Wrapper_check_local(Wrapper *w, const DOHString_or_char *name);
extern char *Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl);
extern char *Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...);
extern Wrapper *NewWrapper();
extern void DelWrapper(Wrapper *w);
extern void Wrapper_print(Wrapper *w, DOHFile *f);
extern int Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl);
extern int Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...);
extern int Wrapper_check_local(Wrapper *w, const DOHString_or_char *name);
extern char *Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl);
extern char *Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...);
extern DataType *Wrapper_Gettype(Wrapper *w);
extern void Wrapper_Settype(Wrapper *w, DataType *t);
extern ParmList *Wrapper_Getparms(Wrapper *w);
extern void Wrapper_Setparms(Wrapper *w, ParmList *l);
extern char *Wrapper_Getname(Wrapper *w);
extern void Wrapper_Setname(Wrapper *w, DOHString_or_char *name);
/* --- Naming functions --- */
@ -205,153 +337,71 @@ extern DOH *Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename,
extern char *Swig_copy_string(const char *c);
extern void Swig_banner(DOHFile *f);
/* --- Legacy DataType interface. This is being replaced --- */
#define T_INT 1
#define T_SHORT 2
#define T_LONG 3
#define T_UINT 4
#define T_USHORT 5
#define T_ULONG 6
#define T_UCHAR 7
#define T_SCHAR 8
#define T_BOOL 9
#define T_DOUBLE 10
#define T_FLOAT 11
#define T_CHAR 12
#define T_USER 13
#define T_VOID 14
#define T_SYMBOL 98
#define T_ERROR 99
/* These types are now obsolete, but defined for backwards compatibility */
#define T_SINT 90
#define T_SSHORT 91
#define T_SLONG 92
#define MAX_NAME 96
typedef struct DataType {
int type; /* SWIG Type code */
char name[MAX_NAME]; /* Name of type */
int is_pointer; /* Is this a pointer */
int implicit_ptr; /* Implicit ptr */
int is_reference; /* A C++ reference type */
int status; /* Is this datatype read-only? */
char *_qualifier; /* A qualifier string (ie. const). */
char *_arraystr; /* String containing array part */
int id; /* type identifier (unique for every type). */
} DataType;
extern DataType *NewDataType(int type);
extern DataType *CopyDataType(DataType *type);
extern void DelDataType(DataType *type);
/* -- New type interface -- */
extern char *DataType_str(DataType *, DOHString_or_char *name); /* Exact datatype */
extern char *DataType_lstr(DataType *, DOHString_or_char *name); /* Assignable datatype */
extern char *DataType_rcaststr(DataType *, DOHString_or_char *name); /* Cast from lstr to str */
extern char *DataType_lcaststr(DataType *, DOHString_or_char *name); /* Cast from str to lstr */
extern char *DataType_manglestr(DataType *t); /* Mangled type name */
extern DataType *DataType_ltype(DataType *); /* Create local type object */
/* -- Old type interface -- */
extern char *DataType_qualifier(DataType *);
extern void DataType_set_qualifier(DataType *, char *q);
extern char *DataType_arraystr(DataType *);
extern void DataType_set_arraystr(DataType *, char *a);
extern char *DataType_mangle_default(DataType *t); /* Default name mangler */
extern void DataType_primitive(DataType *);
extern void DataType_set_mangle(char *(*m)(DataType *));
extern int DataType_array_dimensions(DataType *);
extern char *DataType_get_dimension(DataType *, int);
/* Typedef support */
extern int DataType_typedef_add(DataType *, char *name, int mode);
extern void DataType_typedef_resolve(DataType *, int level);
extern void DataType_typedef_replace(DataType *);
extern int DataType_is_typedef(char *name);
extern void DataType_updatestatus(DataType *, int newstatus);
extern void DataType_init_typedef();
extern void DataType_merge_scope(DOHHash *h);
extern void DataType_new_scope(DOHHash *h);
extern void *DataType_collapse_scope(char *name);
extern void DataType_remember(DataType *);
extern void DataType_record_base(char *derived, char *base);
extern int type_id;
extern void emit_ptr_equivalence(DOHFile *tablef, DOHFile *initf);
extern void emit_type_table(DOHFile *out);
extern void typeeq_derived(char *n1, char *n2, char *cast);
extern void typeeq_addtypedef(char *name, char *eqname, DataType *t);
#define STAT_REPLACETYPE 2
/* --- Deprecated parameter list structure */
typedef struct Parm {
DataType *_type; /* Datatype of this parameter */
char *_name; /* Name of parameter (optional) */
char *_defvalue; /* Default value (as a string) */
char *_lname; /* Local name */
int ignore; /* Ignore flag */
} Parm;
extern Parm *NewParm(DataType *type, char *n);
extern Parm *CopyParm(Parm *p);
extern void DelParm(Parm *p);
extern void Parm_Settype(Parm *p, DataType *t);
extern DataType *Parm_Gettype(Parm *p);
extern void Parm_Setname(Parm *p, char *name);
extern char *Parm_Getname(Parm *p);
extern void Parm_Setlname(Parm *p, char *lname);
extern char *Parm_Getlname(Parm *p);
extern void Parm_Setvalue(Parm *p, char *value);
extern char *Parm_Getvalue(Parm *p);
typedef struct ParmList {
int maxparms; /* Max parms possible in current list */
Parm **parms; /* Pointer to parms array */
int current_parm; /* Internal state for get_first,get_next */
int nparms; /* Number of parms in list */
} ParmList;
extern ParmList *NewParmList();
extern ParmList *CopyParmList(ParmList *);
extern void DelParmList(ParmList *);
extern Parm *ParmList_get(ParmList *l, int pos);
extern void ParmList_append(ParmList *, Parm *);
extern void ParmList_insert(ParmList *, Parm *, int);
extern void ParmList_del(ParmList *, int);
extern int ParmList_numarg(ParmList *);
extern Parm *ParmList_first(ParmList *);
extern Parm *ParmList_next(ParmList *);
extern void ParmList_print_types(ParmList*,DOHFile *f);
extern void ParmList_print_args(ParmList *, DOHFile *f);
extern void Wrapper_local(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *value);
extern char *Wrapper_local_deref(DataType *t, DOHString_or_char *name);
/* --- C Wrappers --- */
extern char *Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value);
extern DataType *Swig_clocal_type(DataType *t);
extern char *Swig_clocal_deref(DataType *t, DOHString_or_char *name);
extern char *Swig_clocal_assign(DataType *t, DOHString_or_char *name);
extern char *Swig_cparm_name(Parm *p, int i);
extern int Swig_cargs(Wrapper *w, ParmList *l);
extern void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl);
extern void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl);
extern char *Swig_cfunction(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cmethod(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cmember_set(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cmember_get(DOHString_or_char *name, ParmList *parms);
extern char *Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value);
extern DataType *Swig_clocal_type(DataType *t);
extern char *Swig_clocal_deref(DataType *t, DOHString_or_char *name);
extern char *Swig_clocal_assign(DataType *t, DOHString_or_char *name);
extern char *Swig_cparm_name(Parm *p, int i);
extern int Swig_cargs(Wrapper *w, ParmList *l);
extern void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl);
extern void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl);
extern char *Swig_cfunction_call(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cmethod_call(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cconstructor_call(DOHString_or_char *name);
extern char *Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms);
extern char *Swig_cdestructor_call();
extern char *Swig_cppdestructor_call();
extern char *Swig_cmemberset_call(DOHString_or_char *name, DataType *t);
extern char *Swig_cmemberget_call(DOHString_or_char *name, DataType *t);
extern Wrapper *Swig_cfunction_wrapper(DOHString_or_char *funcname,
DataType *rtype,
ParmList *parms,
DOHString_or_char *code);
extern Wrapper *Swig_cmethod_wrapper(DOHString_or_char *classname,
DOHString_or_char *methodname,
DataType *rtype,
ParmList *parms,
DOHString_or_char *code);
extern Wrapper *Swig_cdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code);
extern Wrapper *Swig_cppdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code);
extern Wrapper *Swig_cconstructor_wrapper(DOHString_or_char *classname,
ParmList *parms,
DOHString_or_char *code);
extern Wrapper *Swig_cppconstructor_wrapper(DOHString_or_char *classname,
ParmList *parms,
DOHString_or_char *code);
extern Wrapper *Swig_cmemberset_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cmemberget_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cvarset_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cvarget_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code);
#endif

66
SWIG/Source/Swig/wrapfunc.c
View file

@ -17,6 +17,7 @@
static char cvsroot[] = "$Header$";
#include "swig.h"
#include <ctype.h>
/* -----------------------------------------------------------------------------
* NewWrapper()
@ -32,6 +33,9 @@ NewWrapper() {
w->locals = NewString("");
w->code = NewString("");
w->def = NewString("");
w->_type = 0;
w->_parms = 0;
w->_name = 0;
return w;
}
@ -47,6 +51,9 @@ DelWrapper(Wrapper *w) {
Delete(w->locals);
Delete(w->code);
Delete(w->def);
if (w->_type) DelDataType(w->_type);
if (w->_parms) DelParmList(w->_parms);
if (w->_name) Delete(w->_name);
free(w);
}
@ -142,6 +149,7 @@ Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_
}
Setattr(w->localh,name,decl);
Printf(w->locals,"%s;\n", decl);
return 0;
}
/* -----------------------------------------------------------------------------
@ -249,3 +257,61 @@ Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) {
return ret;
}
/* -----------------------------------------------------------------------------
* Wrapper_Gettype()
* ----------------------------------------------------------------------------- */
DataType *
Wrapper_Gettype(Wrapper *w) {
return w->_type;
}
/* -----------------------------------------------------------------------------
* Wrapper_Settype()
* ----------------------------------------------------------------------------- */
void
Wrapper_Settype(Wrapper *w, DataType *t) {
if (w->_type) DelDataType(w->_type);
w->_type = CopyDataType(t);
}
/* -----------------------------------------------------------------------------
* Wrapper_Getparms()
* ----------------------------------------------------------------------------- */
ParmList *
Wrapper_Getparms(Wrapper *w) {
return w->_parms;
}
/* -----------------------------------------------------------------------------
* Wrapper_Setparms()
* ----------------------------------------------------------------------------- */
void
Wrapper_Setparms(Wrapper *w, ParmList *l) {
if (w->_parms) DelParmList(w->_parms);
w->_parms = CopyParmList(l);
}
/* -----------------------------------------------------------------------------
* Wrapper_Getname()
* ----------------------------------------------------------------------------- */
char *
Wrapper_Getname(Wrapper *w) {
return Char(w->_name);
}
/* -----------------------------------------------------------------------------
* Wrapper_Setname()
* ----------------------------------------------------------------------------- */
void
Wrapper_Setname(Wrapper *w, DOHString_or_char *n) {
if (w->_name) Delete(w->_name);
w->_name = NewString(n);
}