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

Cleanup. Replaced Parm and ParmList data structures with new implementation.

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@606 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-07-24 21:48:56 +00:00
commit e036e895d3
18 changed files with 486 additions and 724 deletions
Download patch file Download diff file Expand all files Collapse all files

4
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 oldparms.c cwrap.c
oldtypes.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 oldparms.o cwrap.o
oldtypes.o parms.o cwrap.o
prefix = @prefix@
exec_prefix = @exec_prefix@

146
Source/Swig/cwrap.c
View file

@ -28,8 +28,8 @@ Swig_cparm_name(Parm *p, int i) {
static char name[256];
sprintf(name,"arg%d",i);
if (p) {
Parm_Setlname(p,name);
return Parm_Getlname(p);
Setlname(p,name);
return Getlname(p);
} else {
return name;
}
@ -156,16 +156,16 @@ int Swig_cargs(Wrapper *w, ParmList *l) {
char *lname;
i = 0;
p = ParmList_first(l);
p = Firstitem(l);
while (p != 0) {
lname = Swig_cparm_name(p,i);
pt = Parm_Gettype(p);
pname = Parm_Getname(p);
pvalue = Parm_Getvalue(p);
pt = Gettype(p);
pname = Getname(p);
pvalue = Getvalue(p);
local = Swig_clocal(pt,lname,pvalue);
Wrapper_add_localv(w,lname,local,0);
i++;
p = ParmList_next(l);
p = Nextitem(l);
}
return(i);
}
@ -283,12 +283,12 @@ Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) {
Printf(func,"%s(", name);
p = ParmList_first(parms);
p = Firstitem(parms);
while (p) {
pt = Parm_Gettype(p);
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
i++;
p = ParmList_next(parms);
p = Nextitem(parms);
if (p)
Printf(func,",");
}
@ -315,17 +315,17 @@ Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) {
if (!func) func = NewString("");
Clear(func);
p = ParmList_first(parms);
p = Firstitem(parms);
if (!p) return "";
Printf(func,"%s->%s(", Swig_cparm_name(p,0), name);
i++;
p = ParmList_next(parms);
p = Nextitem(parms);
while (p) {
pt = Parm_Gettype(p);
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
i++;
p = ParmList_next(parms);
p = Nextitem(parms);
if (p)
Printf(func,",");
}
@ -373,12 +373,12 @@ Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) {
Clear(func);
Printf(func,"new %s(", name);
p = ParmList_first(parms);
p = Firstitem(parms);
while (p) {
pt = Parm_Gettype(p);
pt = Gettype(p);
Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
i++;
p = ParmList_next(parms);
p = Nextitem(parms);
if (p)
Printf(func,",");
}
@ -478,15 +478,15 @@ static void fix_parm_names(ParmList *l) {
int i = 0;
Parm *p;
p = ParmList_first(l);
p = Firstitem(l);
while (p) {
if (!Parm_Getname(p)) {
if (!Getname(p)) {
char temp[64];
sprintf(temp,"arg%d",i);
Parm_Setname(p,temp);
Setname(p,temp);
}
i++;
p = ParmList_next(l);
p = Nextitem(l);
}
}
@ -515,15 +515,16 @@ Swig_cfunction_wrapper(DOHString_or_char *funcname,
fix_parm_names(l);
Printf(w->def,"%s %s(%s)", DataType_str(rtype,0), funcname, ParmList_str(l));
Printf(w->def,"%s %s(%s) {", DataType_str(rtype,0), funcname, ParmList_str(l));
if (code) {
Printv(w->code, code, "\n", 0);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,rtype);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
return w;
}
@ -556,28 +557,25 @@ Swig_cmethod_wrapper(DOHString_or_char *classname,
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_insert(l,p,0);
Insert(l,0,p);
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));
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);
p = Firstitem(l);
p = Nextitem(l);
while (p) {
Printf(w->code,"%s", Parm_Getname(p));
p = ParmList_next(l);
Printf(w->code,"%s", Getname(p));
p = Nextitem(l);
if (p)
Printf(w->code,",");
}
@ -585,10 +583,11 @@ Swig_cmethod_wrapper(DOHString_or_char *classname,
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
Printf(w->code,"}\n");
}
Wrapper_Settype(w,rtype);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
return w;
}
@ -621,19 +620,18 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname,
/* 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) {", 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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(t);
return w;
}
@ -668,31 +666,30 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname,
/* 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) {", 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);
p = Firstitem(l);
if (p) {
Printf(w->code,"(");
while (p) {
Printf(w->code,"%s", Parm_Getname(p));
p = ParmList_next(l);
Printf(w->code,"%s", Getname(p));
p = Nextitem(l);
if (p)
Printf(w->code,",");
}
Printf(w->code,")");
}
Printf(w->code,";\n");
Printf(w->code,"}\n");
} else {
Printv(w->code, code, "\n", 0);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(t);
return w;
}
@ -723,25 +720,23 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname,
sprintf(t->name,classname);
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelParm(p);
Append(l,p);
DelDataType(t);
t = NewDataType(T_VOID);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(t);
return w;
}
@ -772,25 +767,24 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname,
sprintf(t->name,classname);
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
DelParm(p);
Append(l,p);
DelDataType(t);
t = NewDataType(T_VOID);
Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,t);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(t);
return w;
}
@ -823,29 +817,26 @@ Swig_cmemberset_wrapper(DOHString_or_char *classname,
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
Append(l,p);
DelDataType(t);
DelParm(p);
lt = Swig_clocal_type(type);
p = NewParm(lt,"value");
ParmList_append(l,p);
DelParm(p);
Append(l,p);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(lt);
return w;
}
@ -879,24 +870,22 @@ Swig_cmemberget_wrapper(DOHString_or_char *classname,
strcpy(t->name,Char(classname));
t->is_pointer++;
p = NewParm(t,"self");
ParmList_append(l,p);
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));
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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(lt);
return w;
}
@ -925,17 +914,14 @@ Swig_cvarset_wrapper(DOHString_or_char *varname,
l = NewParmList();
lt = Swig_clocal_type(type);
p = NewParm(lt,"value");
ParmList_append(l,p);
DelParm(p);
Append(l,p);
Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
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);
@ -943,9 +929,10 @@ Swig_cvarset_wrapper(DOHString_or_char *varname,
Replace(w->code,"$ltype", DataType_str(lt,""), DOH_REPLACE_ANY);
Replace(w->code,"$rtype", DataType_str(type,""), DOH_REPLACE_ANY);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(lt);
return w;
}
@ -974,19 +961,18 @@ 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) {", 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);
}
Printf(w->code,"}\n");
Wrapper_Settype(w,lt);
Wrapper_Setparms(w,l);
DelParmList(l);
Delete(l);
DelDataType(lt);
return w;
}

361
Source/Swig/oldparms.c
View file

@ -1,361 +0,0 @@
/* -----------------------------------------------------------------------------
* parms.cxx
*
* Parameter list class.
*
* !!! This file is deprecated and is being replaced !!!
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1998-2000. The University of Chicago
* Copyright (C) 1995-1998. The University of Utah and The Regents of the
* University of California.
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "swig.h"
#define MAXPARMS 16
/* ------------------------------------------------------------------------
* NewParm()
*
* Create a new parameter from datatype 'type' and name 'n'.
* ------------------------------------------------------------------------ */
Parm *NewParm(DataType *type, char *n) {
Parm *p = (Parm *) malloc(sizeof(Parm));
if (type) {
p->_type = CopyDataType(type);
} else {
p->_type = 0;
}
p->_name = Swig_copy_string(n);
p->_lname = 0;
p->_defvalue = 0;
p->_ignore = 0;
return p;
}
/* ------------------------------------------------------------------------
* CopyParm()
* ------------------------------------------------------------------------ */
Parm *CopyParm(Parm *p) {
Parm *np = (Parm *) malloc(sizeof(Parm));
if (p->_type) np->_type = CopyDataType(p->_type);
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;
return np;
}
/* ------------------------------------------------------------------------
* DelParm()
* ------------------------------------------------------------------------ */
void DelParm(Parm *p) {
if (p->_type) DelDataType(p->_type);
if (p->_name) free(p->_name);
if (p->_defvalue) free(p->_defvalue);
if (p->_lname) free(p->_lname);
free(p);
}
void Parm_Settype(Parm *p, DataType *t) {
if (p->_type) DelDataType(p->_type);
p->_type = CopyDataType(t);
}
DataType *Parm_Gettype(Parm *p) {
return p->_type;
}
void Parm_Setname(Parm *p, char *n) {
if (p->_name) free(p->_name);
p->_name = Swig_copy_string(n);
}
char *Parm_Getname(Parm *p) {
return p->_name;
}
void Parm_Setlname(Parm *p, char *n) {
if (p->_lname) free(p->_lname);
p->_lname = Swig_copy_string(n);
}
char *Parm_Getlname(Parm *p) {
return p->_lname;
}
void Parm_Setvalue(Parm *p, char *v) {
if (p->_defvalue) free(p->_defvalue);
p->_defvalue = Swig_copy_string(v);
}
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()
* ------------------------------------------------------------------ */
ParmList *NewParmList() {
int i;
ParmList *l = (ParmList *) malloc(sizeof(ParmList));
l->nparms = 0;
l->maxparms = MAXPARMS;
l->parms = (Parm **) malloc(MAXPARMS*sizeof(Parm *));
for (i = 0; i < MAXPARMS; i++) {
l->parms[i] = 0;
}
return l;
}
/* ------------------------------------------------------------------
* CopyParmList()
* ------------------------------------------------------------------ */
ParmList *
CopyParmList(ParmList *l) {
ParmList *nl;
int i;
if (l) {
nl = (ParmList *) malloc(sizeof(ParmList));
nl->nparms = l->nparms;
nl->maxparms = l->maxparms;
nl->parms = (Parm **) malloc(l->maxparms*sizeof(Parm*));
for (i = 0; i < l->maxparms; i++) {
if (l->parms[i])
nl->parms[i] = CopyParm(l->parms[i]);
else
nl->parms[i] = 0;
}
return nl;
} else {
return NewParmList();
}
}
/* ------------------------------------------------------------------
* DelParmList()
* ------------------------------------------------------------------ */
void DelParmList(ParmList *l) {
int i;
if (NULL == l) return;
for (i = 0; i < l->maxparms; i++) {
if (l->parms[i]) DelParm(l->parms[i]);
}
free(l->parms);
free(l);
}
/* ------------------------------------------------------------------
* moreparms() - Increase memory for parameter list
* ------------------------------------------------------------------ */
static void moreparms(ParmList *l) {
Parm **newparms;
int i;
newparms = (Parm **) malloc(2*l->maxparms*sizeof(Parm *));
for (i = 0; i < 2*l->maxparms; i++)
newparms[i] = (Parm *) 0;
for (i = 0; i < l->maxparms; i++) {
newparms[i] = l->parms[i];
}
l->maxparms = 2*l->maxparms;
free(l->parms);
l->parms = newparms;
}
/* ------------------------------------------------------------------
* void ParmList_append(ParmList *l, Parm *p)
* ------------------------------------------------------------------ */
void ParmList_append(ParmList *l, Parm *p) {
if (l->nparms == l->maxparms) moreparms(l);
l->parms[l->nparms] = CopyParm(p);
l->nparms++;
}
/* ------------------------------------------------------------------
* void ParmList_insert()
* ------------------------------------------------------------------ */
void ParmList_insert(ParmList *l, Parm *p, int pos) {
int i;
/* If pos is out of range, we'd better fix it */
if (pos < 0) pos = 0;
if (pos > l->nparms) pos = l->nparms;
/* If insertion is going to need more memory, take care of that now */
if (l->nparms >= l->maxparms) moreparms(l);
/* Now shift all of the existing parms to the right */
for (i = l->nparms; i > pos; i--) {
l->parms[i] = l->parms[i-1];
}
/* Set new parameter */
l->parms[pos] = CopyParm(p);
l->nparms++;
}
/* ------------------------------------------------------------------
* void ParmList_del()
* ------------------------------------------------------------------ */
void ParmList_del(ParmList *l, int pos) {
int i;
if (l->nparms <= 0) return;
if (pos < 0) pos = 0;
if (pos >= l->nparms) pos = l->nparms-1;
/* Delete the parameter (if it exists) */
if (l->parms[pos]) DelParm(l->parms[pos]);
/* Now slide all of the parameters to the left */
for (i = pos; i < l->nparms-1; i++) {
l->parms[i] = l->parms[i+1];
}
l->nparms--;
}
/* ------------------------------------------------------------------
* Parm *ParmList_get()
* ------------------------------------------------------------------ */
Parm *ParmList_get(ParmList *l, int pos) {
if ((pos < 0) || (pos >= l->nparms)) return 0;
return l->parms[pos];
}
/* ------------------------------------------------------------------
* int ParmList_numarg()
* ------------------------------------------------------------------ */
int ParmList_numarg(ParmList *l) {
int n = 0;
int i;
for (i = 0; i < l->nparms; i++) {
if (!Parm_Getignore(l->parms[i]))
n++;
}
return n;
}
/* ---------------------------------------------------------------------
* Parm * ParmList_first()
* --------------------------------------------------------------------- */
Parm *ParmList_first(ParmList *l) {
l->current_parm = 0;
if (l->nparms > 0) return l->parms[l->current_parm++];
else return (Parm *) 0;
}
/* ----------------------------------------------------------------------
* Parm *ParmList_next()
* ---------------------------------------------------------------------- */
Parm * ParmList_next(ParmList *l) {
if (l->current_parm >= l->nparms) return 0;
else return l->parms[l->current_parm++];
}
/* ---------------------------------------------------------------------
* void ParmList_print_types(DOHFile *f)
*
* Prints a comma separated list of all of the parameter types.
* This is for generating valid C prototypes.
* ---------------------------------------------------------------------- */
void ParmList_print_types(ParmList *l, DOHFile *f) {
int pn;
DataType *t;
pn = 0;
while(pn < l->nparms) {
t = Parm_Gettype(l->parms[pn]);
Printf(f,"%s", DataType_str(t,0));
pn++;
if (pn < l->nparms)
Printf(f,",");
}
}
/* ---------------------------------------------------------------------
* void ParmList_print_args()
*
* Prints a comma separated list of all of the parameter arguments.
* ---------------------------------------------------------------------- */
void ParmList_print_args(ParmList *l, DOHFile *f) {
int pn;
DataType *t;
pn = 0;
while(pn < l->nparms) {
t = Parm_Gettype(l->parms[pn]);
Printf(f,"%s", DataType_str(t,Parm_Getname(l->parms[pn])));
pn++;
if (pn < l->nparms)
Printf(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);
}

160
Source/Swig/parms.c Normal file
View file

@ -0,0 +1,160 @@
/* -----------------------------------------------------------------------------
* parms.cxx
*
* Parameter list class.
*
* !!! This file is deprecated and is being replaced !!!
*
* Author(s) : David Beazley (beazley@cs.uchicago.edu)
*
* Copyright (C) 1998-2000. The University of Chicago
* Copyright (C) 1995-1998. The University of Utah and The Regents of the
* University of California.
*
* See the file LICENSE for information on usage and redistribution.
* ----------------------------------------------------------------------------- */
static char cvsroot[] = "$Header$";
#include "swig.h"
#define MAXPARMS 16
/* ------------------------------------------------------------------------
* NewParm()
*
* Create a new parameter from datatype 'type' and name 'n'.
* ------------------------------------------------------------------------ */
Parm *NewParm(DataType *type, char *n) {
Parm *p = NewHash();
if (type) {
Setattr(p,"type", NewVoid(CopyDataType(type), (void (*)(void *)) DelDataType));
}
Setattr(p,"name",n);
return p;
}
/* ------------------------------------------------------------------------
* CopyParm()
* ------------------------------------------------------------------------ */
Parm *CopyParm(Parm *p) {
DataType *t;
char *name;
char *lname;
char *value;
int ignore;
Parm *np = NewHash();
t = GetVoid(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));
if (name)
Setattr(np,"name",name);
if (lname)
Setattr(np,"lname", lname);
if (value)
Setattr(np,"value", value);
if (ignore)
SetInt(np,"ignore", ignore);
return np;
}
/* ------------------------------------------------------------------
* NewParmList()
* ------------------------------------------------------------------ */
ParmList *NewParmList() {
return NewList();
}
/* ------------------------------------------------------------------
* CopyParmList()
* ------------------------------------------------------------------ */
ParmList *
CopyParmList(ParmList *l) {
ParmList *nl;
int i, len;
nl = NewList();
len = Len(l);
for (i = 0; i < len; i++) {
Parm *p = Getitem(l,i);
Append(nl, CopyParm(p));
}
return nl;
}
/* ------------------------------------------------------------------
* int ParmList_numarg()
* ------------------------------------------------------------------ */
int ParmList_numarg(ParmList *l) {
int n = 0;
Parm *p;
p = Firstitem(l);
while (p) {
if (Getignore(p)) n++;
p = Nextitem(l);
}
return n;
}
/* ---------------------------------------------------------------------
* ParmList_str()
*
* Generates a string of parameters
* ---------------------------------------------------------------------- */
char *ParmList_str(ParmList *l) {
static DOHString *out = 0;
Parm *p;
DataType *t;
if (!out) out = NewString("");
Clear(out);
p = Firstitem(l);
while(p) {
t = Gettype(p);
Printf(out,"%s", DataType_str(t,Getname(p)));
p = Nextitem(l);
if (p)
Printf(out,",");
}
return Char(out);
}
/* ---------------------------------------------------------------------
* ParmList_str()
*
* Generate a prototype string.
* ---------------------------------------------------------------------- */
char *ParmList_protostr(ParmList *l) {
static DOHString *out = 0;
Parm *p;
DataType *t;
if (!out) out = NewString("");
Clear(out);
p = Firstitem(l);
while(p) {
t = Gettype(p);
Printf(out,"%s", DataType_str(t,0));
p = Nextitem(l);
if (p)
Printf(out,",");
}
return Char(out);
}

100
Source/Swig/swig.h
View file

@ -61,12 +61,12 @@ 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 */
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 -- */
@ -100,50 +100,24 @@ extern void typeeq_addtypedef(char *name, char *eqname, DataType *t);
#define STAT_REPLACETYPE 2
/* --- Deprecated parameter list structure --- */
/* --- Parameters and Parameter Lists --- */
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;
/* Parameters are really just hidden behind a DOH object. The following
interface will probably be simplified even further. */
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 DOH Parm;
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 Parm *NewParm(DataType *type, char *n);
extern Parm *CopyParm(Parm *p);
typedef DOH 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 *);
extern int ParmList_numarg(ParmList *);
extern char *ParmList_str(ParmList *);
extern char *ParmList_protostr(ParmList *);
/* --- File interface --- */
@ -158,11 +132,6 @@ extern int Swig_bytes_read();
#define SWIG_FILE_DELIMETER "/"
/* --- Super Strings --- */
extern DOH *NewSuperString(char *s, DOH *filename, int firstline);
extern int SuperString_check(DOH *s);
/* --- Command line parsing --- */
extern void Swig_init_args(int argc, char **argv);
@ -370,15 +339,15 @@ 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);
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);
ParmList *parms,
DOHString_or_char *code);
extern Wrapper *Swig_cmemberset_wrapper(DOHString_or_char *classname,
@ -391,13 +360,28 @@ extern Wrapper *Swig_cmemberget_wrapper(DOHString_or_char *classname,
DataType *type,
DOHString_or_char *code);
extern Wrapper *Swig_cvarset_wrapper(DOHString_or_char *varname,
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);
extern Wrapper *Swig_cvarget_wrapper(DOHString_or_char *varname,
DataType *type,
DOHString_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 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 Setignore(x,v) SetInt(x,"ignore",v)
#endif

4
Source/Swig/wrapfunc.c
View file

@ -52,7 +52,7 @@ DelWrapper(Wrapper *w) {
Delete(w->code);
Delete(w->def);
if (w->_type) DelDataType(w->_type);
if (w->_parms) DelParmList(w->_parms);
if (w->_parms) Delete(w->_parms);
if (w->_name) Delete(w->_name);
free(w);
}
@ -291,7 +291,7 @@ Wrapper_Getparms(Wrapper *w) {
void
Wrapper_Setparms(Wrapper *w, ParmList *l) {
if (w->_parms) DelParmList(w->_parms);
if (w->_parms) Delete(w->_parms);
w->_parms = CopyParmList(l);
}