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

Completely new type implementation. Almost everything broken. Typemaps sort of work. Tcl is the only working language module. More changes to follow over the next few days.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@651 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-08-14 22:09:56 +00:00
commit fa2942e77c
31 changed files with 2165 additions and 2095 deletions
Download patch file Download diff file Expand all files Collapse all files

4
SWIG/Source/Swig/Makefile.in
View file

@ -6,9 +6,9 @@ srcdir = @srcdir@
VPATH = @srcdir@
SRCS = map.c wrapfunc.c naming.c tree.c stype.c scanner.c include.c getopt.c misc.c \
oldtypes.c parms.c cwrap.c
parms.c cwrap.c
OBJS = map.o wrapfunc.o naming.o tree.o stype.o scanner.o include.o getopt.o misc.o \
oldtypes.o parms.o cwrap.o
parms.o cwrap.o
prefix = @prefix@
exec_prefix = @exec_prefix@

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

@ -23,16 +23,13 @@ static char cvsroot[] = "$Header$";
* Generates a name for the ith argument in an argument list
* ----------------------------------------------------------------------------- */
char *
String *
Swig_cparm_name(Parm *p, int i) {
static char name[256];
sprintf(name,"arg%d",i);
String *name = NewStringf("arg%d",i);
if (p) {
Setlname(p,name);
return Getlname(p);
} else {
return name;
}
return Swig_temp_result(name);
}
/* -----------------------------------------------------------------------------
@ -42,36 +39,35 @@ Swig_cparm_name(Parm *p, int i) {
* and user defined types to pointers.
* ----------------------------------------------------------------------------- */
char *
Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) {
static DOHString *decl = 0;
String *
Swig_clocal(SwigType *t, String_or_char *name, String_or_char *value) {
String *decl;
if (!decl) decl = NewString("");
Clear(decl);
switch(DataType_type(t)) {
decl = NewString("");
switch(SwigType_type(t)) {
case T_USER:
DataType_add_pointer(t);
SwigType_add_pointer(t);
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
Printf(decl,"%s = &%s", SwigType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
DataType_del_pointer(t);
Printf(decl,"%s", SwigType_lstr(t,name));
SwigType_del_pointer(t);
break;
case T_REFERENCE:
if (value)
Printf(decl,"%s = &%s", DataType_lstr(t,name), value);
Printf(decl,"%s = &%s", SwigType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
Printf(decl,"%s", SwigType_lstr(t,name));
break;
case T_VOID:
break;
default:
if (value)
Printf(decl,"%s = %s", DataType_lstr(t,name), value);
Printf(decl,"%s = %s", SwigType_lstr(t,name), value);
else
Printf(decl,"%s", DataType_lstr(t,name));
Printf(decl,"%s", SwigType_lstr(t,name));
}
return Char(decl);
return Swig_temp_result(decl);
}
/* -----------------------------------------------------------------------------
@ -81,23 +77,22 @@ Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) {
* and user defined types to pointers.
* ----------------------------------------------------------------------------- */
DataType *
Swig_clocal_type(DataType *t) {
DataType *ty;
switch(DataType_type(t)) {
SwigType *
Swig_clocal_type(SwigType *t) {
SwigType *ty;
switch(SwigType_type(t)) {
case T_USER:
DataType_add_pointer(t);
ty = DataType_ltype(t);
DataType_del_pointer(t);
SwigType_add_pointer(t);
ty = SwigType_ltype(t);
SwigType_del_pointer(t);
break;
default:
ty = DataType_ltype(t);
ty = SwigType_ltype(t);
break;
}
return ty;
}
/* -----------------------------------------------------------------------------
* Swig_clocal_deref()
*
@ -105,22 +100,19 @@ Swig_clocal_type(DataType *t) {
* the Swig_clocal() function.
* ----------------------------------------------------------------------------- */
char *
Swig_clocal_deref(DataType *t, DOHString_or_char *name) {
static char temp[256];
switch(DataType_type(t)) {
String *
Swig_clocal_deref(SwigType *t, String_or_char *name) {
switch(SwigType_type(t)) {
case T_USER:
sprintf(temp,"*%s",Char(name));
return Swig_temp_result(NewStringf("*%s",name));
break;
case T_VOID:
strcpy(temp,"");
return Swig_temp_result(NewString(""));
break;
default:
sprintf(temp,DataType_rcaststr(t,name));
return SwigType_rcaststr(t,name);
break;
}
return temp;
}
/* -----------------------------------------------------------------------------
@ -129,21 +121,19 @@ Swig_clocal_deref(DataType *t, DOHString_or_char *name) {
* Assigns a value to a local
* ----------------------------------------------------------------------------- */
char *
Swig_clocal_assign(DataType *t, DOHString_or_char *name) {
static char temp[256];
switch(DataType_type(t)) {
String *
Swig_clocal_assign(SwigType *t, String_or_char *name) {
switch(SwigType_type(t)) {
case T_VOID:
strcpy(temp,"");
return Swig_temp_result(NewString(""));
break;
case T_USER:
sprintf(temp,"&%s",Char(name));
return Swig_temp_result(NewStringf("&%s", name));
break;
default:
sprintf(temp,DataType_lcaststr(t,name));
return SwigType_lcaststr(t,name);
break;
}
return temp;
}
/* -----------------------------------------------------------------------------
@ -155,11 +145,11 @@ Swig_clocal_assign(DataType *t, DOHString_or_char *name) {
int Swig_cargs(Wrapper *w, ParmList *p) {
int i;
DataType *pt;
char *pvalue;
char *pname;
char *local;
char *lname;
SwigType *pt;
String *pvalue;
String *pname;
String *local;
String *lname;
i = 0;
while (p != 0) {
@ -182,42 +172,38 @@ int Swig_cargs(Wrapper *w, ParmList *p) {
* function call.
* ----------------------------------------------------------------------------- */
void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
DOHString *fcall;
void Swig_cresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl) {
String *fcall;
fcall = NewString("");
if (DataType_type(t) != T_VOID)
if (SwigType_type(t) != T_VOID)
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
switch(DataType_type(t)) {
switch(SwigType_type(t)) {
case T_VOID:
break;
case T_USER:
DataType_add_pointer(t);
Printv(fcall, name, " = (", DataType_lstr(t,0), ") malloc(sizeof(", 0);
DataType_del_pointer(t);
Printv(fcall, DataType_str(t,0), "));\n", 0);
Printv(fcall, "*(", name, ") = ", 0);
SwigType_add_pointer(t);
Printf(fcall,"%s = (%s) malloc(sizeof(", name, SwigType_lstr(t,0));
SwigType_del_pointer(t);
Printf(fcall, "%s));\n", SwigType_str(t,0));
Printf(fcall, "*(%s) = ", name);
break;
case T_REFERENCE:
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
Printf(fcall,"%s = ", SwigType_str(t,"_result_ref"));
break;
default:
/* Normal return value */
if (DataType_qualifier(t)) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0);
} else {
Printv(fcall, name, " = ", 0);
}
Printf(fcall,"%s = (%s)", name, SwigType_lstr(t,0));
break;
}
/* Now print out function call */
Printv(fcall, decl, ";\n", 0);
if (DataType_type(t) == T_REFERENCE) {
Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0);
if (SwigType_type(t) == T_REFERENCE) {
Printf(fcall,"%s = (%s) &_result_ref;\n", name, SwigType_lstr(t,0));
}
if (Replace(w->code,"$function",fcall, DOH_REPLACE_ANY) == 0) {
@ -233,37 +219,37 @@ void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or
* the C++ default copy constructor for user defined objects.
* ----------------------------------------------------------------------------- */
void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
DOHString *fcall;
void Swig_cppresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl) {
String *fcall;
fcall = NewString("");
if (DataType_type(t) != T_VOID)
if (SwigType_type(t) != T_VOID)
Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0);
switch(DataType_type(t)) {
switch(SwigType_type(t)) {
case T_VOID:
break;
case T_USER:
Printv(fcall, name, " = new ", DataType_str(t,0), "(", 0);
Printf(fcall, "%s = new %s(", name, SwigType_str(t,0));
break;
case T_REFERENCE:
Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
Printf(fcall, "%s = ", SwigType_str(t,"_result_ref"));
break;
default:
Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0);
Printf(fcall, "%s = %s", name, SwigType_lcaststr(t,""));
break;
}
/* Now print out function call */
Printv(fcall, decl, 0);
switch(DataType_type(t)) {
switch(SwigType_type(t)) {
case T_USER:
Printf(fcall,");");
break;
case T_REFERENCE:
Printf(fcall,";\n");
Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0);
Printf(fcall, "%s = (%s) &_result_ref;\n", name, SwigType_lstr(t,0));
break;
default:
Printf(fcall,";\n");
@ -286,27 +272,27 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
*
* ----------------------------------------------------------------------------- */
char *
Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
String *
Swig_cfunction_call(String_or_char *name, ParmList *parms) {
DOH *func;
int i = 0;
Parm *p = parms;
DataType *pt;
if (!func) func = NewString("");
Clear(func);
SwigType *pt;
func = NewString("");
Printf(func,"%s(", name);
while (p) {
String *pname;
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
pname = Swig_cparm_name(p,i);
Printf(func,"%s", Swig_clocal_deref(pt, pname));
i++;
p = Getnext(p);
if (p)
Printf(func,",");
}
Printf(func,")");
return Char(func);
return Swig_temp_result(func);
}
/* -----------------------------------------------------------------------------
@ -318,30 +304,30 @@ Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) {
*
* ----------------------------------------------------------------------------- */
char *
Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
String *
Swig_cmethod_call(String_or_char *name, ParmList *parms) {
DOH *func;
int i = 0;
Parm *p = parms;
DataType *pt;
SwigType *pt;
if (!func) func = NewString("");
Clear(func);
if (!p) return "";
func = NewString("");
if (!p) return Swig_temp_result(func);
Printf(func,"%s->%s(", Swig_cparm_name(p,0), name);
i++;
p = Getnext(p);
while (p) {
String *pname;
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
pname = Swig_cparm_name(p,i);
Printf(func,"%s", Swig_clocal_deref(pt, pname));
i++;
p = Getnext(p);
if (p)
Printf(func,",");
}
Printf(func,")");
return Char(func);
return Swig_temp_result(func);
}
/* -----------------------------------------------------------------------------
@ -352,15 +338,13 @@ Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) {
* (name *) calloc(1,sizeof(name));
* ----------------------------------------------------------------------------- */
char *
Swig_cconstructor_call(DOHString_or_char *name) {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
String *
Swig_cconstructor_call(String_or_char *name) {
DOH *func;
func = NewString("");
Printf(func,"(%s *) calloc(1, sizeof(%s))", name, name);
return Char(func);
return Swig_temp_result(func);
}
@ -374,26 +358,26 @@ Swig_cconstructor_call(DOHString_or_char *name) {
*
* ----------------------------------------------------------------------------- */
char *
Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) {
static DOH *func = 0;
String *
Swig_cppconstructor_call(String_or_char *name, ParmList *parms) {
DOH *func;
int i = 0;
Parm *p = parms;
DataType *pt;
if (!func) func = NewString("");
Clear(func);
SwigType *pt;
func = NewString("");
Printf(func,"new %s(", name);
while (p) {
String *pname;
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
pname = Swig_cparm_name(p,i);
Printf(func,"%s", Swig_clocal_deref(pt, pname));
i++;
p = Getnext(p);
if (p)
Printf(func,",");
}
Printf(func,")");
return Char(func);
return Swig_temp_result(func);
}
@ -405,15 +389,14 @@ Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) {
* free((char *) arg0);
* ----------------------------------------------------------------------------- */
char *
String *
Swig_cdestructor_call() {
static DOH *func = 0;
DOH *func;
if (!func) func = NewString("");
Clear(func);
func = NewString("");
Printf(func,"free((char *) %s)", Swig_cparm_name(0,0));
return Char(func);
return Swig_temp_result(func);
}
@ -425,15 +408,13 @@ Swig_cdestructor_call() {
* delete arg0;
* ----------------------------------------------------------------------------- */
char *
String *
Swig_cppdestructor_call() {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
DOH *func;
func = NewString("");
Printf(func,"delete %s", Swig_cparm_name(0,0));
return Char(func);
return Swig_temp_result(func);
}
/* -----------------------------------------------------------------------------
@ -445,21 +426,20 @@ Swig_cppdestructor_call() {
*
* ----------------------------------------------------------------------------- */
char *
Swig_cmemberset_call(DOHString_or_char *name, DataType *type) {
static DOH *func = 0;
String *
Swig_cmemberset_call(String_or_char *name, SwigType *type) {
DOH *func;
String *pname;
func = NewString("");
if (!func) func = NewString("");
Clear(func);
if (DataType_type(type) == T_USER) {
if (SwigType_type(type) == T_USER) {
Printf(func,"%s %s->%s; ", Swig_clocal_assign(type,""), Swig_cparm_name(0,0), name);
} else {
Printf(func,"%s ", Swig_clocal_assign(type,""));
}
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);
Printf(func,"%s)", Swig_clocal_deref(type, (pname = Swig_cparm_name(0,1))));
return Swig_temp_result(func);
}
@ -472,15 +452,13 @@ Swig_cmemberset_call(DOHString_or_char *name, DataType *type) {
*
* ----------------------------------------------------------------------------- */
char *
Swig_cmemberget_call(DOHString_or_char *name, DataType *t) {
static DOH *func = 0;
if (!func) func = NewString("");
Clear(func);
String *
Swig_cmemberget_call(String_or_char *name, SwigType *t) {
DOH *func;
func = NewString("");
Printf(func,"%s (%s->%s)", Swig_clocal_assign(t,""),Swig_cparm_name(0,0), name);
return Char(func);
return Swig_temp_result(func);
}
@ -505,10 +483,10 @@ static void fix_parm_names(ParmList *p) {
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cfunction_wrapper(DOHString_or_char *funcname,
DataType *rtype,
Swig_cfunction_wrapper(String_or_char *funcname,
SwigType *rtype,
ParmList *parms,
DOHString_or_char *code)
String_or_char *code)
{
Wrapper *w;
ParmList *l;
@ -520,7 +498,7 @@ Swig_cfunction_wrapper(DOHString_or_char *funcname,
l = CopyParmList(parms);
fix_parm_names(l);
Printf(w->def,"%s %s(%s) {", DataType_str(rtype,0), funcname, ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(rtype,0), funcname, ParmList_str(l));
if (code) {
Printv(w->code, code, "\n", 0);
}
@ -540,16 +518,16 @@ Swig_cfunction_wrapper(DOHString_or_char *funcname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmethod_wrapper(DOHString_or_char *classname,
DOHString_or_char *methodname,
DataType *rtype,
Swig_cmethod_wrapper(String_or_char *classname,
String_or_char *methodname,
SwigType *rtype,
ParmList *parms,
DOHString_or_char *code)
String_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
SwigType *t;
w = NewWrapper();
@ -557,21 +535,20 @@ Swig_cmethod_wrapper(DOHString_or_char *classname,
Wrapper_Setname(w,Swig_name_member(classname, methodname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
DataType_Setname(t, Char(classname));
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
p = NewParm(t,"self");
Setnext(p,l);
DelDataType(t);
Delete(t);
l = p;
fix_parm_names(l);
Printf(w->def,"%s %s(%s) {", DataType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
if (DataType_type(rtype) != T_VOID) {
if (SwigType_type(rtype) != T_VOID) {
Printf(w->code,"return ");
}
@ -603,13 +580,13 @@ Swig_cmethod_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cconstructor_wrapper(DOHString_or_char *classname,
Swig_cconstructor_wrapper(String_or_char *classname,
ParmList *parms,
DOHString_or_char *code)
String_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
SwigType *t;
w = NewWrapper();
@ -617,18 +594,17 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname,
Wrapper_Setname(w,Swig_name_construct(classname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
DataType_Setname(t,classname);
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
/* 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));
Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_construct(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", DataType_str(t,0), classname);
Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", SwigType_str(t,0), classname);
} else {
Printv(w->code, code, "\n", 0);
}
@ -636,11 +612,10 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(t);
Delete(t);
return w;
}
/* -----------------------------------------------------------------------------
* Swig_cppconstructor_wrapper()
*
@ -648,13 +623,13 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cppconstructor_wrapper(DOHString_or_char *classname,
Swig_cppconstructor_wrapper(String_or_char *classname,
ParmList *parms,
DOHString_or_char *code)
String_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
SwigType *t;
Parm *p;
w = NewWrapper();
@ -663,18 +638,17 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname,
Wrapper_Setname(w,Swig_name_construct(classname));
l = CopyParmList(parms);
t = NewDataType(T_USER);
DataType_Setname(t,classname);
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
/* 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));
Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_construct(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
Printf(w->code,"return new %s", DataType_str(t,0));
Printf(w->code,"return new %s", SwigType_str(t,0));
p = l;
if (p) {
Printf(w->code,"(");
@ -694,7 +668,7 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(t);
Delete(t);
return w;
}
@ -706,12 +680,12 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code)
Swig_cdestructor_wrapper(String_or_char *classname,
String_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
SwigType *t;
Parm *p;
w = NewWrapper();
@ -719,16 +693,15 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname,
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_destroy(classname));
t = NewDataType(T_USER);
DataType_Setname(t,classname);
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
p = NewParm(t,"self");
l = p;
DelDataType(t);
Delete(t);
t = NewDataType(T_VOID);
t = NewString("void");
Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -740,7 +713,7 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(t);
Delete(t);
return w;
}
@ -752,12 +725,12 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cppdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code)
Swig_cppdestructor_wrapper(String_or_char *classname,
String_or_char *code)
{
Wrapper *w;
ParmList *l;
DataType *t;
SwigType *t;
Parm *p;
w = NewWrapper();
@ -765,17 +738,16 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname,
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_destroy(classname));
t = NewDataType(T_USER);
DataType_Setname(t,classname);
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
p = NewParm(t,"self");
l = p;
DelDataType(t);
Delete(t);
t = NewDataType(T_VOID);
t = NewString("void");
Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -787,7 +759,7 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(t);
Delete(t);
return w;
}
@ -798,34 +770,33 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmemberset_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code)
Swig_cmemberset_wrapper(String_or_char *classname,
String_or_char *membername,
SwigType *type,
String_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
DataType *lt;
SwigType *t;
SwigType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_member(classname, Swig_name_set(membername)));
t = NewDataType(T_USER);
DataType_Setname(t, Char(classname));
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
p = NewParm(t,"self");
l = p;
DelDataType(t);
Delete(t);
lt = Swig_clocal_type(type);
p = NewParm(lt,"value");
Setnext(l,p);
Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -838,7 +809,7 @@ Swig_cmemberset_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(lt);
Delete(lt);
return w;
}
@ -850,31 +821,30 @@ Swig_cmemberset_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cmemberget_wrapper(DOHString_or_char *classname,
DOHString_or_char *membername,
DataType *type,
DOHString_or_char *code)
Swig_cmemberget_wrapper(String_or_char *classname,
String_or_char *membername,
SwigType *type,
String_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *t;
DataType *lt;
SwigType *t;
SwigType *lt;
w = NewWrapper();
/* Set the name of the function */
Wrapper_Setname(w,Swig_name_member(classname, Swig_name_get(membername)));
t = NewDataType(T_USER);
DataType_Setname(t, Char(classname));
DataType_add_pointer(t);
t = NewString(classname);
SwigType_add_pointer(t);
p = NewParm(t,"self");
l = p;
DelDataType(t);
Delete(t);
lt = Swig_clocal_type(type);
Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -886,7 +856,7 @@ Swig_cmemberget_wrapper(DOHString_or_char *classname,
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(lt);
Delete(lt);
return w;
}
@ -897,14 +867,14 @@ Swig_cmemberget_wrapper(DOHString_or_char *classname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cvarset_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code)
Swig_cvarset_wrapper(String_or_char *varname,
SwigType *type,
String_or_char *code)
{
Wrapper *w;
ParmList *l;
Parm *p;
DataType *lt;
SwigType *lt;
w = NewWrapper();
@ -915,7 +885,7 @@ Swig_cvarset_wrapper(DOHString_or_char *varname,
p = NewParm(lt,"value");
l = p;
Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -925,14 +895,14 @@ Swig_cvarset_wrapper(DOHString_or_char *varname,
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);
Replace(w->code,"$ltype", SwigType_str(lt,""), DOH_REPLACE_ANY);
Replace(w->code,"$rtype", SwigType_str(type,""), DOH_REPLACE_ANY);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(lt);
Delete(lt);
return w;
}
@ -943,13 +913,13 @@ Swig_cvarset_wrapper(DOHString_or_char *varname,
* ----------------------------------------------------------------------------- */
Wrapper *
Swig_cvarget_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code)
Swig_cvarget_wrapper(String_or_char *varname,
SwigType *type,
String_or_char *code)
{
Wrapper *w;
ParmList *l = 0;
DataType *lt;
SwigType *lt;
w = NewWrapper();
@ -958,7 +928,7 @@ Swig_cvarget_wrapper(DOHString_or_char *varname,
lt = Swig_clocal_type(type);
Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
if (!code) {
/* No code supplied. Write a function manually */
@ -970,7 +940,7 @@ Swig_cvarget_wrapper(DOHString_or_char *varname,
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
Delete(l);
DelDataType(lt);
Delete(lt);
return w;
}

34
SWIG/Source/Swig/include.c
View file

@ -17,8 +17,8 @@ static char cvsroot[] = "$Header$";
/* Delimeter used in accessing files and directories */
static DOHList *directories = 0; /* List of include directories */
static DOHString *lastpath = 0; /* Last file that was included */
static List *directories = 0; /* List of include directories */
static String *lastpath = 0; /* Last file that was included */
static int bytes_read = 0; /* Bytes read */
/* -----------------------------------------------------------------------------
@ -28,7 +28,7 @@ static int bytes_read = 0; /* Bytes read */
* ----------------------------------------------------------------------------- */
void
Swig_add_directory(const DOHString_or_char *dirname) {
Swig_add_directory(const String_or_char *dirname) {
if (!directories) directories = NewList();
assert(directories);
if (!DohIsString(dirname)) {
@ -44,7 +44,7 @@ Swig_add_directory(const DOHString_or_char *dirname) {
* Returns the full pathname of the last file opened.
* ----------------------------------------------------------------------------- */
DOHString *
String *
Swig_last_file() {
assert(lastpath);
return lastpath;
@ -56,11 +56,11 @@ Swig_last_file() {
* Returns a list of the current search paths.
* ----------------------------------------------------------------------------- */
DOHList *
List *
Swig_search_path() {
DOHString *filename;
DOHString *dirname;
DOHList *slist;
String *filename;
String *dirname;
List *slist;
int i;
slist = NewList();
@ -86,10 +86,10 @@ Swig_search_path() {
* ----------------------------------------------------------------------------- */
FILE *
Swig_open(const DOHString_or_char *name) {
Swig_open(const String_or_char *name) {
FILE *f;
DOHString *filename;
DOHList *spath = 0;
String *filename;
List *spath = 0;
char *cname;
int i;
@ -124,10 +124,10 @@ Swig_open(const DOHString_or_char *name) {
* Reads data from an open FILE * and returns it as a string.
* ----------------------------------------------------------------------------- */
DOHString *
String *
Swig_read_file(FILE *f) {
char buffer[4096];
DOHString *str = NewString("");
String *str = NewString("");
assert(str);
while (fgets(buffer,4095,f)) {
@ -144,10 +144,10 @@ Swig_read_file(FILE *f) {
* ----------------------------------------------------------------------------- */
static int readbytes = 0;
DOHString *
Swig_include(const DOHString_or_char *name) {
String *
Swig_include(const String_or_char *name) {
FILE *f;
DOHString *str;
String *str;
f = Swig_open(name);
if (!f) return 0;
@ -173,7 +173,7 @@ Swig_bytes_read() {
* ----------------------------------------------------------------------------- */
int
Swig_insert_file(const DOHString_or_char *filename, DOHFile *outfile) {
Swig_insert_file(const String_or_char *filename, File *outfile) {
char buffer[4096];
int nbytes;
FILE *f = Swig_open(filename);

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

@ -52,17 +52,17 @@ static char cvsroot[] = "$Header$";
* ----------------------------------------------------------------------------- */
void
Swig_map_add_parmrule(DOHHash *ruleset, DOHHash *parms, DOH *obj)
Swig_map_add_parmrule(Hash *ruleset, Hash *parms, DOH *obj)
{
DOHHash *p, *n;
Hash *p, *n;
/* Walk down the parms list and create a series of hash tables */
p = parms;
n = ruleset;
while (p) {
DOHString *ty, *name, *key;
DOHHash *nn;
String *ty, *name, *key;
Hash *nn;
ty = Getattr(p,"type");
name = Getattr(p,"name");
@ -95,8 +95,8 @@ Swig_map_add_parmrule(DOHHash *ruleset, DOHHash *parms, DOH *obj)
* ----------------------------------------------------------------------------- */
void
Swig_map_add_typerule(DOHHash *ruleset, DOH *type, DOHString_or_char *name, DOH *obj) {
DOHHash *p;
Swig_map_add_typerule(Hash *ruleset, DOH *type, String_or_char *name, DOH *obj) {
Hash *p;
p = NewHash();
Setattr(p,"type",type);
@ -109,8 +109,8 @@ Swig_map_add_typerule(DOHHash *ruleset, DOH *type, DOHString_or_char *name, DOH
typedef struct MatchObject {
DOH *ruleset; /* Hash table of rules */
DOHHash *p; /* Parameter on which checking starts */
Hash *ruleset; /* Hash table of rules */
Hash *p; /* Parameter on which checking starts */
int depth; /* Depth of the match */
struct MatchObject *next; /* Next match object */
} MatchObject;
@ -131,7 +131,7 @@ static MatchObject *matchstack = 0;
* ----------------------------------------------------------------------------- */
DOH *
Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch)
Swig_map_match_parms(Hash *ruleset, Hash *parms, int *nmatch)
{
MatchObject *mo;
@ -151,15 +151,15 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch)
/* Loop over all candidates until we find the best one */
while (matchstack) {
DOHHash *rs;
DOHHash *p;
int depth = 0;
DOH *obj;
DOHString *key;
DOHString *ty;
DOHString *name;
DOHString *nm;
int matched = 0;
Hash *rs;
Hash *p;
int depth = 0;
DOH *obj;
String *key;
String *ty;
String *name;
String *nm;
int matched = 0;
mo = matchstack;
/* See if there is a match at this level */
@ -223,7 +223,7 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch)
int ndim;
int i, j, n;
int ncheck;
DOHString *ntype;
String *ntype;
key = NewString("");
@ -304,8 +304,8 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch)
} else {
/* If there is no match at all. I guess we can check for a default type */
DOH *rs;
DOHString *key;
DOHString *dty = SwigType_default(Getattr(parms,"type"));
String *key;
String *dty = SwigType_default(Getattr(parms,"type"));
key = NewStringf("*map:-%s",dty);
rs = Getattr(ruleset,key);
@ -332,8 +332,8 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch)
* ----------------------------------------------------------------------------- */
DOH *
Swig_map_match_type(DOHHash *ruleset, DOH *type, DOHString_or_char *name) {
DOHHash *p;
Swig_map_match_type(Hash *ruleset, DOH *type, String_or_char *name) {
Hash *p;
DOH *obj;
int nmatch;

44
SWIG/Source/Swig/misc.c
View file

@ -37,7 +37,7 @@ Swig_copy_string(const char *s) {
* ----------------------------------------------------------------------------- */
void
Swig_banner(DOHFile *f) {
Swig_banner(File *f) {
Printf(f,
"/* ----------------------------------------------------------------------------\n\
* This file was automatically generated by SWIG (http://www.swig.org).\n\
@ -56,6 +56,48 @@ Swig_banner(DOHFile *f) {
}
/* -----------------------------------------------------------------------------
* Swig_temp_result()
*
* This function is used to return a "temporary" result--a result that is only
* guaranteed to exist for a short period of time. Typically this is used by
* functions that return strings and other intermediate results that are
* used in print statements.
*
* Note: this is really a bit of a kludge to make it easier to work with
* temporary variables (so that the caller doesn't have to worry about
* memory management). In theory, it is possible to break this if an
* operation produces so many temporaries that it overflows the internal
* array before they are used. However, in practice, this would only
* occur for very deep levels of recursion or functions taking lots of
* parameters---neither of which occur very often in SWIG (if at all).
* Also, a user can prevent destruction of a temporary object by increasing
* it's reference count using DohIncref().
*
* It is an error to place two identical results onto this list. It is also
* an error for a caller to free anything returned by this function.
*
* Note: SWIG1.1 did something similar to this in a less-organized manner.
* ----------------------------------------------------------------------------- */
#define MAX_RESULT 512
static DOH *results[MAX_RESULT];
static int results_index = 0;
static int results_init = 0;
DOH *Swig_temp_result(DOH *x) {
int i;
if (!results_init) {
for (i = 0; i < MAX_RESULT; i++) results[i] = 0;
results_init = 1;
}
/* Printf(stdout,"results_index = %d, %x, '%s'\n", results_index, x, x); */
if (results[results_index]) Delete(results[results_index]);
results[results_index] = x;
results_index = (results_index + 1) % MAX_RESULT;
return x;
}

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

@ -16,7 +16,7 @@ static char cvsroot[] = "$Header$";
/* Hash table containing naming data */
static DOH *naming_hash = 0;
static Hash *naming_hash = 0;
/* -----------------------------------------------------------------------------
* Swig_name_register()
@ -24,7 +24,8 @@ static DOH *naming_hash = 0;
* Register a new naming format.
* ----------------------------------------------------------------------------- */
void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format) {
void
Swig_name_register(String_or_char *method, String_or_char *format) {
if (!naming_hash) naming_hash = NewHash();
Setattr(naming_hash,method,format);
}
@ -35,18 +36,17 @@ void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format) {
* Converts all of the non-identifier characters of a string to underscores.
* ----------------------------------------------------------------------------- */
char *Swig_name_mangle(DOHString_or_char *s) {
static DOHString *r = 0;
String *
Swig_name_mangle(String_or_char *s) {
String *r = NewString("");
char *c;
if (!r) r = NewString("");
Clear(r);
Append(r,s);
c = Char(r);
while (*c) {
if (!isalnum(*c)) *c = '_';
c++;
}
return Char(r);
return Swig_temp_result(r);
}
/* -----------------------------------------------------------------------------
@ -55,13 +55,13 @@ char *Swig_name_mangle(DOHString_or_char *s) {
* Returns the name of a wrapper function.
* ----------------------------------------------------------------------------- */
char *Swig_name_wrapper(DOHString_or_char *fname) {
static DOHString *r = 0;
DOHString *f;
String *
Swig_name_wrapper(String_or_char *fname) {
String *r;
String *f;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"wrapper");
if (!f) {
Append(r,"_wrap_%f");
@ -69,7 +69,7 @@ char *Swig_name_wrapper(DOHString_or_char *fname) {
Append(r,f);
}
Replace(r,"%f",fname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}
@ -79,14 +79,14 @@ char *Swig_name_wrapper(DOHString_or_char *fname) {
* Returns the name of a class method.
* ----------------------------------------------------------------------------- */
char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
static DOHString *r = 0;
DOHString *f;
String *
Swig_name_member(String_or_char *classname, String_or_char *mname) {
String *r;
String *f;
char *cname, *c;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"member");
if (!f) {
Append(r,"%c_%m");
@ -98,7 +98,7 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
Replace(r,"%m",mname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}
/* -----------------------------------------------------------------------------
@ -107,13 +107,13 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
* Returns the name of the accessor function used to get a variable.
* ----------------------------------------------------------------------------- */
char *Swig_name_get(DOHString_or_char *vname) {
static DOHString *r = 0;
DOHString *f;
String *
Swig_name_get(String_or_char *vname) {
String *r;
String *f;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"get");
if (!f) {
Append(r,"%v_get");
@ -121,7 +121,7 @@ char *Swig_name_get(DOHString_or_char *vname) {
Append(r,f);
}
Replace(r,"%v",vname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}
/* -----------------------------------------------------------------------------
@ -130,13 +130,13 @@ char *Swig_name_get(DOHString_or_char *vname) {
* Returns the name of the accessor function used to set a variable.
* ----------------------------------------------------------------------------- */
char *Swig_name_set(DOHString_or_char *vname) {
static DOHString *r = 0;
DOHString *f;
String *
Swig_name_set(String_or_char *vname) {
String *r;
String *f;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"set");
if (!f) {
Append(r,"%v_set");
@ -144,7 +144,7 @@ char *Swig_name_set(DOHString_or_char *vname) {
Append(r,f);
}
Replace(r,"%v",vname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}
/* -----------------------------------------------------------------------------
@ -153,13 +153,13 @@ char *Swig_name_set(DOHString_or_char *vname) {
* Returns the name of the accessor function used to create an object.
* ----------------------------------------------------------------------------- */
char *Swig_name_construct(DOHString_or_char *classname) {
static DOHString *r = 0;
DOHString *f;
String *
Swig_name_construct(String_or_char *classname) {
String *r;
String *f;
char *cname, *c;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"construct");
if (!f) {
Append(r,"new_%c");
@ -172,7 +172,7 @@ char *Swig_name_construct(DOHString_or_char *classname) {
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}
@ -182,13 +182,12 @@ char *Swig_name_construct(DOHString_or_char *classname) {
* Returns the name of the accessor function used to destroy an object.
* ----------------------------------------------------------------------------- */
char *Swig_name_destroy(DOHString_or_char *classname) {
static DOHString *r = 0;
DOHString *f;
String *Swig_name_destroy(String_or_char *classname) {
String *r;
String *f;
char *cname, *c;
if (!r) r = NewString("");
r = NewString("");
if (!naming_hash) naming_hash = NewHash();
Clear(r);
f = Getattr(naming_hash,"destroy");
if (!f) {
Append(r,"delete_%c");
@ -201,8 +200,9 @@ char *Swig_name_destroy(DOHString_or_char *classname) {
if (c) cname = c+1;
Replace(r,"%c",cname, DOH_REPLACE_ANY);
return Char(r);
return Swig_temp_result(r);
}

36
SWIG/Source/Swig/parms.c
View file

@ -26,11 +26,11 @@ static char cvsroot[] = "$Header$";
* Create a new parameter from datatype 'type' and name 'n'.
* ------------------------------------------------------------------------ */
Parm *NewParm(DataType *type, char *n) {
Parm *NewParm(SwigType *type, String_or_char *n) {
Parm *p = NewHash();
if (type) {
Setattr(p,"type", NewVoid(CopyDataType(type), (void (*)(void *)) DelDataType));
Setattr(p,"type", Copy(type));
}
Setattr(p,"name",n);
return p;
@ -41,20 +41,20 @@ Parm *NewParm(DataType *type, char *n) {
* ------------------------------------------------------------------------ */
Parm *CopyParm(Parm *p) {
DataType *t;
SwigType *t;
char *name;
char *lname;
char *value;
int ignore;
Parm *np = NewHash();
t = GetVoid(p,"type");
t = Getattr(p,"type");
name = GetChar(p,"name");
lname = GetChar(p,"lname");
value = GetChar(p,"value");
ignore = GetInt(p,"ignore");
Setattr(np,"type",NewVoid(CopyDataType(t), (void (*)(void *)) DelDataType));
Setattr(np,"type",Copy(t));
if (name)
Setattr(np,"name",name);
if (lname)
@ -123,20 +123,19 @@ int ParmList_len(ParmList *p) {
* Generates a string of parameters
* ---------------------------------------------------------------------- */
char *ParmList_str(ParmList *p) {
static DOHString *out = 0;
DataType *t;
String *ParmList_str(ParmList *p) {
String *out;
SwigType *t;
if (!out) out = NewString("");
Clear(out);
out = NewString("");
while(p) {
t = Gettype(p);
Printf(out,"%s", DataType_str(t,Getname(p)));
Printf(out,"%s", SwigType_str(t,Getname(p)));
p = Getnext(p);
if (p)
Printf(out,",");
}
return Char(out);
return Swig_temp_result(out);
}
/* ---------------------------------------------------------------------
@ -145,20 +144,19 @@ char *ParmList_str(ParmList *p) {
* Generate a prototype string.
* ---------------------------------------------------------------------- */
char *ParmList_protostr(ParmList *p) {
static DOHString *out = 0;
DataType *t;
String *ParmList_protostr(ParmList *p) {
String *out;
SwigType *t;
if (!out) out = NewString("");
Clear(out);
out = NewString("");
while(p) {
t = Gettype(p);
Printf(out,"%s", DataType_str(t,0));
Printf(out,"%s", SwigType_str(t,0));
p = Getnext(p);
if (p)
Printf(out,",");
}
return Char(out);
return Swig_temp_result(out);
}

16
SWIG/Source/Swig/scanner.c
View file

@ -18,16 +18,16 @@ static char cvsroot[] = "$Header$";
#include <ctype.h>
struct SwigScanner {
DOHString *text; /* Current token value */
DOHList *scanobjs; /* Objects being scanned */
DOHString *str; /* Current object being scanned */
String *text; /* Current token value */
List *scanobjs; /* Objects being scanned */
String *str; /* Current object being scanned */
char *idstart; /* Optional identifier start characters */
int nexttoken; /* Next token to be returned */
int start_line; /* Starting line of certain declarations */
int string_start;
int line;
int yylen; /* Length of text pushed into text */
DOHString *file;
String *file;
};
/* -----------------------------------------------------------------------------
@ -95,7 +95,7 @@ SwigScanner_clear(SwigScanner *s) {
* ----------------------------------------------------------------------------- */
void
SwigScanner_push(SwigScanner *s, DOHString *txt) {
SwigScanner_push(SwigScanner *s, String *txt) {
assert(s && txt);
Push(s->scanobjs,txt);
if (s->str) Delete(s->str);
@ -125,7 +125,7 @@ SwigScanner_pushtoken(SwigScanner *s, int nt) {
* ----------------------------------------------------------------------------- */
void
SwigScanner_set_location(SwigScanner *s, DOHString *file, int line) {
SwigScanner_set_location(SwigScanner *s, String *file, int line) {
Setline(s->str,line);
Setfile(s->str,file);
}
@ -136,7 +136,7 @@ SwigScanner_set_location(SwigScanner *s, DOHString *file, int line) {
* Get the current file.
* ----------------------------------------------------------------------------- */
DOHString *
String *
SwigScanner_get_file(SwigScanner *s) {
return Getfile(s->str);
}
@ -671,7 +671,7 @@ SwigScanner_token(SwigScanner *s) {
* Return the lexene associated with the last returned token.
* ----------------------------------------------------------------------------- */
DOHString *
String *
SwigScanner_text(SwigScanner *s) {
return s->text;
}

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

File diff suppressed because it is too large Load diff

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

@ -22,140 +22,57 @@
#include "doh.h"
/* Short names for common data types */
typedef DOH String;
typedef DOH Hash;
typedef DOH List;
typedef DOH String_or_char;
typedef DOH File;
/* --- 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_STRING 20
#define T_POINTER 21
#define T_REFERENCE 22
#define T_ARRAY 23
#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);
int DataType_type(DataType *t);
int DataType_Gettypecode(DataType *t);
void DataType_Settypecode(DataType *t, int type);
void DataType_Setname(DataType *t, char *name);
char *DataType_Getname(DataType *t);
/* -- 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 */
void DataType_add_reference(DataType *t);
int DataType_is_reference(DataType *t);
int DataType_is_pointer(DataType *t);
void DataType_add_pointer(DataType *t);
void DataType_del_pointer(DataType *t);
/* -- Old type interface. This is going away -- */
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
/* --- Parameters and Parameter Lists --- */
/* Parameters are really just hidden behind a DOH object. The following
interface will probably be simplified even further. */
typedef DOH Parm;
extern Parm *NewParm(DataType *type, char *n);
extern Parm *CopyParm(Parm *p);
typedef DOH ParmList;
extern ParmList *CopyParmList(ParmList *);
extern int ParmList_len(ParmList *);
extern int ParmList_numarg(ParmList *);
extern char *ParmList_str(ParmList *);
extern char *ParmList_protostr(ParmList *);
#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_STRING 20
#define T_POINTER 21
#define T_REFERENCE 22
#define T_ARRAY 23
#define T_FUNCTION 24
#define T_SYMBOL 98
#define T_ERROR 99
/* --- File interface --- */
extern void Swig_add_directory(const DOHString_or_char *dirname);
extern DOHString *Swig_last_file();
extern DOHList *Swig_search_path();
extern FILE *Swig_open(const DOHString_or_char *name);
extern DOHString *Swig_read_file(FILE *f);
extern DOHString *Swig_include(const DOHString_or_char *name);
extern int Swig_insert_file(const DOHString_or_char *name, DOHFile *outfile);
extern int Swig_bytes_read();
extern void Swig_add_directory(const String_or_char *dirname);
extern String *Swig_last_file();
extern List *Swig_search_path();
extern FILE *Swig_open(const String_or_char *name);
extern String *Swig_read_file(FILE *f);
extern String *Swig_include(const String_or_char *name);
extern int Swig_insert_file(const String_or_char *name, File *outfile);
extern int Swig_bytes_read();
#define SWIG_FILE_DELIMETER "/"
/* --- Command line parsing --- */
extern void Swig_init_args(int argc, char **argv);
extern void Swig_mark_arg(int n);
extern void Swig_check_options();
extern void Swig_arg_error();
extern void Swig_init_args(int argc, char **argv);
extern void Swig_mark_arg(int n);
extern void Swig_check_options();
extern void Swig_arg_error();
/* --- Scanner Interface --- */
@ -164,14 +81,14 @@ typedef struct SwigScanner SwigScanner;
extern SwigScanner *NewSwigScanner();
extern void DelSwigScanner(SwigScanner *);
extern void SwigScanner_clear(SwigScanner *);
extern void SwigScanner_push(SwigScanner *, DOHString *);
extern void SwigScanner_push(SwigScanner *, String *);
extern void SwigScanner_pushtoken(SwigScanner *, int);
extern int SwigScanner_token(SwigScanner *);
extern DOHString *SwigScanner_text(SwigScanner *);
extern String *SwigScanner_text(SwigScanner *);
extern void SwigScanner_skip_line(SwigScanner *);
extern int SwigScanner_skip_balanced(SwigScanner *, int startchar, int endchar);
extern void SwigScanner_set_location(SwigScanner *, DOHString *file, int line);
extern DOHString *SwigScanner_get_file(SwigScanner *);
extern void SwigScanner_set_location(SwigScanner *, String *file, int line);
extern String *SwigScanner_get_file(SwigScanner *);
extern int SwigScanner_get_line(SwigScanner *);
extern void SwigScanner_idstart(SwigScanner *, char *idchar);
@ -227,43 +144,72 @@ extern void SwigScanner_idstart(SwigScanner *, char *idchar);
#define SWIG_TOKEN_LAST 99
/* --- Functions for manipulating the string-based type encoding --- */
typedef DOH SwigType;
extern void SwigType_add_pointer(DOHString *t);
extern void SwigType_add_array(DOHString *t, DOHString_or_char *size);
extern void SwigType_add_reference(DOHString *t);
extern void SwigType_add_qualifier(DOHString *t, DOHString_or_char *qual);
extern void SwigType_add_function(DOHString *t, DOHList *parms);
extern DOHList *SwigType_split(DOHString *t);
extern DOHString *SwigType_pop(DOHString *t);
extern void SwigType_push(DOHString *t, DOHString *s);
extern DOHList *SwigType_parmlist(DOHString *p);
extern DOHString *SwigType_parm(DOHString *p);
extern DOHString *SwigType_str(DOHString *s, DOHString_or_char *id);
extern DOHString *SwigType_lstr(DOHString *s, DOHString_or_char *id);
extern DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *id);
extern DOHString *SwigType_lcaststr(DOHString *s, DOHString_or_char *id);
extern int SwigType_ispointer(DOHString_or_char *t);
extern int SwigType_isreference(DOHString_or_char *t);
extern int SwigType_isarray(DOHString_or_char *t);
extern int SwigType_isfunction(DOHString_or_char *t);
extern int SwigType_isqualifier(DOHString_or_char *t);
extern DOHString *SwigType_base(DOHString_or_char *t);
extern DOHString *SwigType_prefix(DOHString_or_char *t);
extern SwigType *NewSwigType(int typecode);
extern void SwigType_add_pointer(SwigType *t);
extern void SwigType_del_pointer(SwigType *t);
extern void SwigType_add_array(SwigType *t, String_or_char *size);
extern void SwigType_add_reference(SwigType *t);
extern void SwigType_add_qualifier(SwigType *t, String_or_char *qual);
extern void SwigType_add_function(SwigType *t, List *parms);
extern List *SwigType_split(SwigType *t);
extern String *SwigType_pop(SwigType *t);
extern void SwigType_push(SwigType *t, SwigType *s);
extern List *SwigType_parmlist(SwigType *p);
extern String *SwigType_parm(String *p);
extern String *SwigType_str(SwigType *s, String_or_char *id);
extern String *SwigType_lstr(SwigType *s, String_or_char *id);
extern String *SwigType_rcaststr(SwigType *s, String_or_char *id);
extern String *SwigType_lcaststr(SwigType *s, String_or_char *id);
extern String *SwigType_manglestr(SwigType *t);
extern SwigType *SwigType_ltype(SwigType *t);
extern int SwigType_ispointer(SwigType *t);
extern int SwigType_isreference(SwigType *t);
extern int SwigType_isarray(SwigType *t);
extern int SwigType_isfunction(SwigType *t);
extern int SwigType_isqualifier(SwigType *t);
extern int SwigType_isconst(SwigType *t);
extern int SwigType_typedef(DOHString_or_char *type, DOHString_or_char *name);
extern String *SwigType_base(SwigType *t);
extern String *SwigType_prefix(SwigType *t);
extern void SwigType_setbase(SwigType *t, String_or_char *name);
extern int SwigType_typedef(SwigType *type, String_or_char *name);
extern void SwigType_inherit(String *subclass, String *baseclass);
extern void SwigType_new_scope();
extern void SwigType_reset_scopes();
extern void SwigType_set_scope_name(DOHString_or_char *name);
extern void SwigType_merge_scope(DOHHash *scope, DOHString_or_char *prefix);
extern DOHHash *SwigType_pop_scope();
extern DOHString *SwigType_typedef_resolve(DOHString_or_char *t);
extern int SwigType_istypedef(DOHString_or_char *t);
extern int SwigType_cmp(DOHString_or_char *pat, DOHString_or_char *t);
extern int SwigType_array_ndim(DOHString_or_char *t);
extern DOHString *SwigType_array_getdim(DOHString_or_char *t, int n);
extern void SwigType_array_setdim(DOHString_or_char *t, int n, DOHString_or_char *rep);
extern DOHString *SwigType_default(DOHString_or_char *t);
extern void SwigType_set_scope_name(String_or_char *name);
extern void SwigType_merge_scope(Hash *scope, String_or_char *prefix);
extern Hash *SwigType_pop_scope();
extern String *SwigType_typedef_resolve(SwigType *t);
extern int SwigType_istypedef(SwigType *t);
extern int SwigType_cmp(String_or_char *pat, SwigType *t);
extern int SwigType_array_ndim(SwigType *t);
extern String *SwigType_array_getdim(SwigType *t, int n);
extern void SwigType_array_setdim(SwigType *t, int n, String_or_char *rep);
extern String *SwigType_default(SwigType *t);
extern int SwigType_type(SwigType *t);
extern void SwigType_remember(SwigType *t);
extern void SwigType_emit_type_table(File *f_headers, File *f_table);
/* --- Parameters and Parameter Lists --- */
/* Parameters are really just hidden behind a DOH object. The following
interface will probably be simplified even further. */
typedef DOH Parm;
extern Parm *NewParm(SwigType *type, String_or_char *n);
extern Parm *CopyParm(Parm *p);
typedef DOH ParmList;
extern ParmList *CopyParmList(ParmList *);
extern int ParmList_len(ParmList *);
extern int ParmList_numarg(ParmList *);
extern String *ParmList_str(ParmList *);
extern String *ParmList_protostr(ParmList *);
/* --- Parse tree support --- */
@ -273,7 +219,7 @@ typedef struct {
} SwigRule;
extern void Swig_dump_tags(DOH *obj, DOH *root);
extern void Swig_add_rule(DOHString_or_char *, int (*action)(DOH *, void *));
extern void Swig_add_rule(String_or_char *, int (*action)(DOH *, void *));
extern void Swig_add_rules(SwigRule ruleset[]);
extern void Swig_clear_rules();
extern int Swig_emit(DOH *obj, void *clientdata);
@ -284,125 +230,126 @@ extern DOH *Swig_prev(DOH *obj);
/* -- Wrapper function Object */
typedef struct {
DataType *_type;
SwigType *_type;
ParmList *_parms;
DOHString *_name;
DOHHash *localh;
DOHString *def;
DOHString *locals;
DOHString *code;
String *_name;
Hash *localh;
String *def;
String *locals;
String *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 DataType *Wrapper_Gettype(Wrapper *w);
extern void Wrapper_Settype(Wrapper *w, DataType *t);
extern void Wrapper_print(Wrapper *w, File *f);
extern int Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl);
extern int Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...);
extern int Wrapper_check_local(Wrapper *w, const String_or_char *name);
extern char *Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl);
extern char *Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...);
extern SwigType *Wrapper_Gettype(Wrapper *w);
extern void Wrapper_Settype(Wrapper *w, SwigType *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);
extern void Wrapper_Setname(Wrapper *w, String_or_char *name);
/* --- Naming functions --- */
extern void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format);
extern char *Swig_name_mangle(DOHString_or_char *s);
extern char *Swig_name_wrapper(DOHString_or_char *fname);
extern char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname);
extern char *Swig_name_get(DOHString_or_char *vname);
extern char *Swig_name_set(DOHString_or_char *vname);
extern char *Swig_name_construct(DOHString_or_char *classname);
extern char *Swig_name_destroy(DOHString_or_char *classname);
extern void Swig_name_register(String_or_char *method, String_or_char *format);
extern String *Swig_name_mangle(String_or_char *s);
extern String *Swig_name_wrapper(String_or_char *fname);
extern String *Swig_name_member(String_or_char *classname, String_or_char *mname);
extern String *Swig_name_get(String_or_char *vname);
extern String *Swig_name_set(String_or_char *vname);
extern String *Swig_name_construct(String_or_char *classname);
extern String *Swig_name_destroy(String_or_char *classname);
/* --- Mapping interface --- */
extern void Swig_map_add(DOHHash *ruleset, DOHHash *parms, DOH *obj);
extern DOH *Swig_map_match(DOHHash *ruleset, DOHHash *parms, int *nmatch);
extern void Swig_map_add(Hash *ruleset, Hash *parms, DOH *obj);
extern DOH *Swig_map_match(Hash *ruleset, Hash *parms, int *nmatch);
/* --- Misc --- */
extern char *Swig_copy_string(const char *c);
extern void Swig_banner(DOHFile *f);
extern char *Swig_copy_string(const char *c);
extern void Swig_banner(File *f);
extern DOH *Swig_temp_result(DOH *x);
/* --- 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 String *Swig_clocal(SwigType *t, String_or_char *name, String_or_char *value);
extern SwigType *Swig_clocal_type(SwigType *t);
extern String *Swig_clocal_deref(SwigType *t, String_or_char *name);
extern String *Swig_clocal_assign(SwigType *t, String_or_char *name);
extern String *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 void Swig_cresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl);
extern void Swig_cppresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl);
extern String *Swig_cfunction_call(String_or_char *name, ParmList *parms);
extern String *Swig_cmethod_call(String_or_char *name, ParmList *parms);
extern String *Swig_cconstructor_call(String_or_char *name);
extern String *Swig_cppconstructor_call(String_or_char *name, ParmList *parms);
extern String *Swig_cdestructor_call();
extern String *Swig_cppdestructor_call();
extern String *Swig_cmemberset_call(String_or_char *name, SwigType *t);
extern String *Swig_cmemberget_call(String_or_char *name, SwigType *t);
extern Wrapper *Swig_cfunction_wrapper(DOHString_or_char *funcname,
DataType *rtype,
extern Wrapper *Swig_cfunction_wrapper(String_or_char *funcname,
SwigType *rtype,
ParmList *parms,
DOHString_or_char *code);
String_or_char *code);
extern Wrapper *Swig_cmethod_wrapper(DOHString_or_char *classname,
DOHString_or_char *methodname,
DataType *rtype,
extern Wrapper *Swig_cmethod_wrapper(String_or_char *classname,
String_or_char *methodname,
SwigType *rtype,
ParmList *parms,
DOHString_or_char *code);
String_or_char *code);
extern Wrapper *Swig_cdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code);
extern Wrapper *Swig_cdestructor_wrapper(String_or_char *classname,
String_or_char *code);
extern Wrapper *Swig_cppdestructor_wrapper(DOHString_or_char *classname,
DOHString_or_char *code);
extern Wrapper *Swig_cppdestructor_wrapper(String_or_char *classname,
String_or_char *code);
extern Wrapper *Swig_cconstructor_wrapper(DOHString_or_char *classname,
extern Wrapper *Swig_cconstructor_wrapper(String_or_char *classname,
ParmList *parms,
DOHString_or_char *code);
String_or_char *code);
extern Wrapper *Swig_cppconstructor_wrapper(DOHString_or_char *classname,
extern Wrapper *Swig_cppconstructor_wrapper(String_or_char *classname,
ParmList *parms,
DOHString_or_char *code);
String_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_cmemberset_wrapper(String_or_char *classname,
String_or_char *membername,
SwigType *type,
String_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_cmemberget_wrapper(String_or_char *classname,
String_or_char *membername,
SwigType *type,
String_or_char *code);
extern Wrapper *Swig_cvarset_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cvarset_wrapper(String_or_char *varname,
SwigType *type,
String_or_char *code);
extern Wrapper *Swig_cvarget_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cvarget_wrapper(String_or_char *varname,
SwigType *type,
String_or_char *code);
/* --- Attribute access macros --- */
#define Gettype(x) ((DataType *) GetVoid(x,"type"))
#define Getname(x) GetChar(x,"name")
#define Getvalue(x) GetChar(x,"value")
#define Getlname(x) GetChar(x,"lname")
#define Gettype(x) Getattr(x,"type")
#define Getname(x) Getattr(x,"name")
#define Getvalue(x) Getattr(x,"value")
#define Getlname(x) Getattr(x,"lname")
#define Getignore(x) GetInt(x,"ignore")
#define Settype(x,v) Setattr(x,"type",NewVoid(CopyDataType(v), (void (*)(void *)) DelDataType));
#define Setname(x,v) SetChar(x,"name",Char(v))
#define Setlname(x,v) SetChar(x,"lname",Char(v))
#define Setvalue(x,v) SetChar(x,"value", Char(v))
#define Settype(x,v) Setattr(x,"type",x)
#define Setname(x,v) Setattr(x,"name",v)
#define Setlname(x,v) Setattr(x,"lname",v)
#define Setvalue(x,v) Setattr(x,"value", v)
#define Setignore(x,v) SetInt(x,"ignore",v)
#define Getnext(x) Getattr(x,"next")

4
SWIG/Source/Swig/tree.c
View file

@ -14,7 +14,7 @@
static char cvsroot[] = "$Header$";
static DOHHash *rules = 0;
static Hash *rules = 0;
/* -----------------------------------------------------------------------------
* Swig_next()
@ -66,7 +66,7 @@ Swig_dump_tags(DOH *obj, DOH *root) {
* ----------------------------------------------------------------------------- */
void
Swig_add_rule(DOHString_or_char *name, int (*action)(DOH *node, void *clientdata))
Swig_add_rule(String_or_char *name, int (*action)(DOH *node, void *clientdata))
{
if (!rules) rules = NewHash();
if (action)

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

@ -51,7 +51,7 @@ DelWrapper(Wrapper *w) {
Delete(w->locals);
Delete(w->code);
Delete(w->def);
if (w->_type) DelDataType(w->_type);
Delete(w->_type);
Delete(w->_parms);
Delete(w->_name);
free(w);
@ -64,8 +64,8 @@ DelWrapper(Wrapper *w) {
* ----------------------------------------------------------------------------- */
void
Wrapper_pretty_print(DOHString *str, DOHFile *f) {
DOHString *ts;
Wrapper_pretty_print(String *str, File *f) {
String *ts;
int level = 0;
int c, i;
int empty = 1;
@ -124,8 +124,8 @@ Wrapper_pretty_print(DOHString *str, DOHFile *f) {
* ----------------------------------------------------------------------------- */
void
Wrapper_print(Wrapper *w, DOHFile *f) {
DOHString *str;
Wrapper_print(Wrapper *w, File *f) {
String *str;
str = NewString("");
Printf(str,"%s\n", w->def);
@ -142,7 +142,7 @@ Wrapper_print(Wrapper *w, DOHFile *f) {
* ----------------------------------------------------------------------------- */
int
Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl) {
Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) {
/* See if the local has already been declared */
if (Getattr(w->localh,name)) {
return -1;
@ -161,10 +161,10 @@ Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_
* ----------------------------------------------------------------------------- */
int
Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...) {
Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...) {
va_list ap;
int ret;
DOHString *decl;
String *decl;
DOH *obj;
decl = NewString("");
va_start(ap,name);
@ -189,7 +189,7 @@ Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...) {
* ----------------------------------------------------------------------------- */
int
Wrapper_check_local(Wrapper *w, const DOHString_or_char *name) {
Wrapper_check_local(Wrapper *w, const String_or_char *name) {
if (Getattr(w->localh,name)) {
return 1;
}
@ -204,10 +204,10 @@ Wrapper_check_local(Wrapper *w, const DOHString_or_char *name) {
* ----------------------------------------------------------------------------- */
char *
Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl) {
Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) {
int i;
DOHString *nname = NewString(name);
DOHString *ndecl = NewString(decl);
String *nname = NewString(name);
String *ndecl = NewString(decl);
char *ret;
i = 0;
@ -236,10 +236,10 @@ Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_
* ----------------------------------------------------------------------------- */
char *
Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) {
Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...) {
va_list ap;
char *ret;
DOHString *decl;
String *decl;
DOH *obj;
decl = NewString("");
va_start(ap,name);
@ -261,7 +261,7 @@ Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) {
* Wrapper_Gettype()
* ----------------------------------------------------------------------------- */
DataType *
SwigType *
Wrapper_Gettype(Wrapper *w) {
return w->_type;
}
@ -271,9 +271,9 @@ Wrapper_Gettype(Wrapper *w) {
* ----------------------------------------------------------------------------- */
void
Wrapper_Settype(Wrapper *w, DataType *t) {
if (w->_type) DelDataType(w->_type);
w->_type = CopyDataType(t);
Wrapper_Settype(Wrapper *w, SwigType *t) {
Delete(w->_type);
w->_type = Copy(t);
}
/* -----------------------------------------------------------------------------
@ -310,9 +310,13 @@ Wrapper_Getname(Wrapper *w) {
* ----------------------------------------------------------------------------- */
void
Wrapper_Setname(Wrapper *w, DOHString_or_char *n) {
Wrapper_Setname(Wrapper *w, String_or_char *n) {
Delete(w->_name);
w->_name = NewString(n);
}