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

Continued thrashing of the Language API

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@927 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-10-20 03:49:32 +00:00
commit d376fa3517
17 changed files with 354 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

10
Source/Modules1.1/guile.cxx
View file

@ -498,7 +498,7 @@ GUILE::function (DOH *node) {
Replace(proc_name,"_", "-", DOH_REPLACE_ANY);
/* Emit locals etc. into f->code; figure out which args to ignore */
emit_args (d, l, f);
emit_args (node, f);
/* Declare return variable */
@ -599,7 +599,7 @@ GUILE::function (DOH *node) {
// Now write code to make the function call
Printv(f->code, tab4, "gh_defer_ints();\n", 0);
emit_func_call (name, d, l, f);
emit_func_call (node, f);
Printv(f->code, tab4, "gh_allow_ints();\n", 0);
// Now have return value, figure out what to do with it.
@ -968,17 +968,17 @@ GUILE::constant(DOH *node)
DelWrapper(f);
}
void GUILE::cpp_variable(char *name, char *iname, SwigType *t)
void GUILE::cpp_variable(DOH *node)
{
if (emit_setters) {
struct_member = 1;
Printf(f_init, "{\n");
Language::cpp_variable(name, iname, t);
Language::cpp_variable(node);
Printf(f_init, "}\n");
struct_member = 0;
}
else {
/* Only emit traditional VAR-get and VAR-set procedures */
Language::cpp_variable(name, iname, t);
Language::cpp_variable(node);
}
}

2
Source/Modules1.1/guile.h
View file

@ -53,7 +53,7 @@ public :
void set_module(char *);
void set_init (char *);
void create_command (char *, char *) { };
void cpp_variable(char *name, char *iname, SwigType *t);
void cpp_variable(DOH *node);
};
/* guile.h ends here */

4
Source/Modules1.1/mzscheme.cxx
View file

@ -311,7 +311,7 @@ MZSCHEME::function(DOH *node)
// they are called arg0, arg1, ...
// the return value is called result
int pcount = emit_args(d, l, f);
int pcount = emit_args(node, f);
int numargs = 0;
int numopt = 0;
@ -389,7 +389,7 @@ MZSCHEME::function(DOH *node)
// Now write code to make the function call
emit_func_call (name, d, l, f);
emit_func_call (node, f);
// Now have return value, figure out what to do with it.

80
Source/Modules1.1/perl5.cxx
View file

@ -523,7 +523,7 @@ PERL5::function(DOH *node)
Printv(f->def, "XS(", Swig_name_wrapper(iname), ") {\n", 0);
pcount = emit_args(d, l, f);
pcount = emit_args(node, f);
numopt = check_numopt(l);
Wrapper_add_local(f,"argvi","int argvi = 0");
@ -650,7 +650,7 @@ PERL5::function(DOH *node)
/* Now write code to make the function call */
emit_func_call(name,d,l,f);
emit_func_call(node,f);
if ((tm = Swig_typemap_lookup((char*)"out",d,iname,(char*)"result",(char*)"ST(argvi)",0))) {
Printf(f->code, "%s\n", tm);
@ -1275,10 +1275,13 @@ PERL5::usage_func(char *iname, SwigType *, ParmList *l) {
}
/* -----------------------------------------------------------------------------
* PERL5::add_native()
* PERL5::nativefunction()
* ----------------------------------------------------------------------------- */
void
PERL5::add_native(char *name, char *funcname, SwigType *, ParmList *) {
PERL5::nativefunction(DOH *node) {
char *name, *funcname;
name = GetChar(node,"scriptname");
funcname = GetChar(node,"name");
Printf(f_init,"\t newXS(\"%s::%s\", %s, file);\n", package,name, funcname);
if (export_all)
Printf(exported,"%s ",name);
@ -1495,7 +1498,10 @@ PERL5::cpp_close_class() {
* PERL5::cpp_member_func()
* ----------------------------------------------------------------------------- */
void
PERL5::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
PERL5::cpp_memberfunction(DOH *node) {
char *name, *iname;
SwigType *t;
ParmList *l;
String *func;
char *realname;
Parm *p;
@ -1506,10 +1512,15 @@ PERL5::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
int need_wrapper = 0;
member_func = 1;
this->Language::cpp_member_func(name,iname,t,l);
this->Language::cpp_memberfunction(node);
member_func = 0;
if (!blessed) return;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
func = NewString("");
cname = NewString("perl5:");
@ -1632,8 +1643,9 @@ PERL5::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
* is in the list, we tie it, otherwise, we just return the normal SWIG value.
* ----------------------------------------------------------------------------- */
void PERL5::cpp_variable(char *name, char *iname, SwigType *t) {
void PERL5::cpp_variable(DOH *node) {
char *name, *iname;
SwigType *t;
char *realname;
String *cname;
@ -1642,13 +1654,18 @@ void PERL5::cpp_variable(char *name, char *iname, SwigType *t) {
/* Emit a pair of get/set functions for the variable */
member_func = 1;
this->Language::cpp_variable(name, iname, t);
this->Language::cpp_variable(node);
member_func = 0;
if (iname) realname = iname;
else realname = name;
if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
if (iname) realname = iname;
else realname = name;
Printf(cname,"%s::%s", class_name, realname);
if (Getattr(symbols,cname)) {
Delete(cname);
@ -1684,7 +1701,9 @@ void PERL5::cpp_variable(char *name, char *iname, SwigType *t) {
* something that wasn't necessarily allocated by malloc or new
* ----------------------------------------------------------------------------- */
void
PERL5::cpp_constructor(char *name, char *iname, ParmList *l) {
PERL5::cpp_constructor(DOH *node) {
char *name, *iname;
ParmList *l;
Parm *p;
int i;
String *realname;
@ -1695,10 +1714,12 @@ PERL5::cpp_constructor(char *name, char *iname, ParmList *l) {
/* Emit an old-style constructor for this class */
member_func = 1;
this->Language::cpp_constructor(name, iname, l);
this->Language::cpp_constructor(node);
if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
l = Getattr(node,"parms");
if (iname)
realname = iname;
else {
@ -1769,12 +1790,16 @@ PERL5::cpp_constructor(char *name, char *iname, ParmList *l) {
* PERL5::cpp_destructor()
* ----------------------------------------------------------------------------- */
void
PERL5::cpp_destructor(char *name, char *newname) {
PERL5::cpp_destructor(DOH *node) {
String *realname;
char *name, *newname;
member_func = 1;
this->Language::cpp_destructor(name, newname);
this->Language::cpp_destructor(node);
if (blessed) {
name = GetChar(node,"name");
newname = GetChar(node,"scriptname");
if (newname) realname = newname;
else {
if (class_renamed) realname = class_name;
@ -1801,16 +1826,20 @@ PERL5::cpp_destructor(char *name, char *newname) {
}
/* -----------------------------------------------------------------------------
* PERL5::cpp_static_func()
* PERL5::cpp_staticfunction()
* ----------------------------------------------------------------------------- */
void
PERL5::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) {
this->Language::cpp_static_func(name,iname,t,l);
PERL5::cpp_staticfunction(DOH *node) {
char *name, *iname;
this->Language::cpp_staticfunction(node);
char *realname;
if (iname) realname = name;
else realname = iname;
if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
if (iname) realname = name;
else realname = iname;
Printv(pcode, "*", realname, " = *", realpackage, "::", Swig_name_member(class_name,realname), ";\n", 0);
}
}
@ -1854,20 +1883,23 @@ PERL5::cpp_inherit(char **baseclass, int) {
}
/* -----------------------------------------------------------------------------
* PERL5::cpp_declare_const()
* PERL5::cpp_constant()
* ----------------------------------------------------------------------------- */
void
PERL5::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) {
PERL5::cpp_constant(DOH *node) {
char *name, *iname;
String *realname;
int oldblessed = blessed;
char cname[256];
/* Create a normal constant */
blessed = 0;
this->Language::cpp_declare_const(name, iname, type, value);
this->Language::cpp_constant(node);
blessed = oldblessed;
if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
if (!iname)
realname = name;
else

14
Source/Modules1.1/perl5.h
View file

@ -31,20 +31,20 @@ public :
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);
virtual void add_native(char *, char *, SwigType *, ParmList *);
virtual void nativefunction(DOH *);
virtual void create_command(char *, char *);
// Support for blessed perl thingies....
virtual void cpp_open_class(char *classname, char *rename, char *ctype, int strip);
virtual void cpp_close_class();
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_variable(char *name, char *iname, SwigType *t);
virtual void cpp_constructor(char *name, char *iname, ParmList *l);
virtual void cpp_destructor(char *name, char *newname);
virtual void cpp_memberfunction(DOH *);
virtual void cpp_staticfunction(DOH *);
virtual void cpp_variable(DOH *);
virtual void cpp_constructor(DOH *);
virtual void cpp_destructor(DOH *);
virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL);
virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value);
virtual void cpp_constant(DOH *);
virtual void cpp_class_decl(char *, char *, char *);
virtual void add_typedef(SwigType *t, char *name);
virtual void pragma(char *, char *, char *);

59
Source/Modules1.1/python.cxx
View file

@ -379,7 +379,7 @@ PYTHON::function(DOH *node) {
usage = usage_func(iname,d,l);
/* Write code to extract function parameters. */
pcount = emit_args(d, l, f);
pcount = emit_args(node, f);
if (!use_kw) {
Printf(parse_args," if(!PyArg_ParseTuple(args,\"");
} else {
@ -550,7 +550,7 @@ PYTHON::function(DOH *node) {
Printv(f->code, parse_args, get_pointers, check, 0);
/* Emit the function call */
emit_func_call(name,d,l,f);
emit_func_call(node,f);
/* Return the function value */
if ((tm = Swig_typemap_lookup((char*)"out",d,iname,(char*)"result",(char*)"resultobj",0))) {
@ -1017,10 +1017,15 @@ PYTHON::usage_func(char *iname, SwigType *, ParmList *l) {
}
/* -----------------------------------------------------------------------------
* PYTHON::add_native()
* PYTHON::nativefunctin()
* ----------------------------------------------------------------------------- */
void
PYTHON::add_native(char *name, char *funcname, SwigType *, ParmList *) {
PYTHON::nativefunction(DOH *node) {
char *name;
char *funcname;
name = GetChar(node,"scriptname");
funcname = GetChar(node,"name");
add_method(name, funcname,0);
if (shadow) {
Printv(func, name, " = ", module, ".", name, "\n\n", 0);
@ -1245,17 +1250,24 @@ PYTHON::cpp_open_class(char *classname, char *rname, char *ctype, int strip) {
* PYTHON::cpp_member_func()
* ----------------------------------------------------------------------------- */
void
PYTHON::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
PYTHON::cpp_memberfunction(DOH *node) {
char *realname;
char *name, *iname;
SwigType *t;
ParmList *l;
int oldshadow;
char cname[1024];
/* Create the default member function */
oldshadow = shadow; /* Disable shadowing when wrapping member functions */
if (shadow) shadow = shadow | PYSHADOW_MEMBER;
this->Language::cpp_member_func(name,iname,t,l);
this->Language::cpp_memberfunction(node);
shadow = oldshadow;
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
realname = iname ? iname : name;
/* Check to see if we've already seen this */
@ -1305,16 +1317,21 @@ PYTHON::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
* PYTHON::cpp_constructor()
* ----------------------------------------------------------------------------- */
void
PYTHON::cpp_constructor(char *name, char *iname, ParmList *l) {
PYTHON::cpp_constructor(DOH *node) {
char *name, *iname;
ParmList *l;
char *realname;
int oldshadow = shadow;
char cname[1024];
if (shadow) shadow = shadow | PYSHADOW_MEMBER;
this->Language::cpp_constructor(name,iname,l);
this->Language::cpp_constructor(node);
shadow = oldshadow;
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
l = Getattr(node,"parms");
realname = iname ? iname : class_name;
/* Check to see if we've already seen this */
@ -1359,14 +1376,17 @@ PYTHON::cpp_constructor(char *name, char *iname, ParmList *l) {
* PYTHON::cpp_destructor()
* ----------------------------------------------------------------------------- */
void
PYTHON::cpp_destructor(char *name, char *newname) {
PYTHON::cpp_destructor(DOH *node) {
char *name, *newname;
char *realname;
int oldshadow = shadow;
if (shadow) shadow = shadow | PYSHADOW_MEMBER;
this->Language::cpp_destructor(name,newname);
this->Language::cpp_destructor(node);
shadow = oldshadow;
if (shadow) {
name = GetChar(node,"name");
newname = GetChar(node,"scriptname");
if (newname) realname = newname;
else realname = class_renamed ? class_name : name;
@ -1495,17 +1515,22 @@ PYTHON::cpp_inherit(char **baseclass,int) {
* PYTHON::cpp_variable() - Add a member variable
* ----------------------------------------------------------------------------- */
void
PYTHON::cpp_variable(char *name, char *iname, SwigType *t) {
PYTHON::cpp_variable(DOH *node) {
char *name, *iname;
SwigType *t;
char *realname;
int inhash = 0;
int oldshadow = shadow;
char cname[512];
if (shadow) shadow = shadow | PYSHADOW_MEMBER;
this->Language::cpp_variable(name,iname,t);
this->Language::cpp_variable(node);
shadow = oldshadow;
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
have_getattr = 1;
have_setattr = 1;
realname = iname ? iname : name;
@ -1536,16 +1561,22 @@ PYTHON::cpp_variable(char *name, char *iname, SwigType *t) {
* PYTHON::cpp_declare_const()
* ----------------------------------------------------------------------------- */
void
PYTHON::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) {
PYTHON::cpp_constant(DOH *node) {
char *name, *iname, *value;
SwigType *type;
char *realname;
int oldshadow = shadow;
char cname[512];
if (shadow) shadow = shadow | PYSHADOW_MEMBER;
this->Language::cpp_declare_const(name,iname,type,value);
this->Language::cpp_constant(node);
shadow = oldshadow;
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
type = Getattr(node,"type");
value = GetChar(node,"value");
realname = iname ? iname : name;
/* Check to see if we've already seen this */

14
Source/Modules1.1/python.h
View file

@ -36,23 +36,25 @@ public :
virtual void function(DOH *node);
virtual void variable(DOH *node);
virtual void constant(DOH *node);
virtual void nativefunction(DOH *);
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);
virtual void add_native(char *, char *, SwigType *, ParmList *);
virtual void create_command(char *, char *);
virtual void import(char *);
// C++ extensions---for creating shadow classes
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_constructor(char *name, char *iname, ParmList *l);
virtual void cpp_destructor(char *name, char *newname);
virtual void cpp_memberfunction(DOH *);
virtual void cpp_constructor(DOH *);
virtual void cpp_destructor(DOH *);
virtual void cpp_open_class(char *classname, char *rname, char *ctype, int strip);
virtual void cpp_close_class();
virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL);
virtual void cpp_variable(char *name, char *iname, SwigType *t);
virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value);
virtual void cpp_variable(DOH *);
virtual void cpp_constant(DOH *);
virtual void cpp_class_decl(char *, char *,char *);
virtual void pragma(char *, char *, char *);
virtual void cpp_pragma(Pragma *);

44
Source/Modules1.1/ruby.cxx
View file

@ -347,11 +347,11 @@ void RUBY::close(void) {
}
/* --------------------------------------------------------------------------
* RUBY::add_native()
* RUBY::nativefunction()
* -------------------------------------------------------------------------- */
void
RUBY::add_native(char *name, char *funcname, SwigType *, ParmList *) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, funcname);
RUBY::nativefunction(DOH *node) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, Getattr(node,"scriptname"));
}
/* ---------------------------------------------------------------------
@ -451,7 +451,7 @@ void RUBY::function(DOH *node) {
/* Ruby needs no destructor wrapper */
if (current == DESTRUCTOR) {
Wrapper *dummy = NewWrapper();
emit_func_call(name,t,l,dummy);
emit_func_call(node,dummy);
DelWrapper(dummy);
return;
}
@ -532,7 +532,7 @@ void RUBY::function(DOH *node) {
}
}
}
int pcount = emit_args(t,l,f);
int pcount = emit_args(node,f);
/* Emit count to check the number of arguments */
if (vararg) {
@ -621,7 +621,7 @@ void RUBY::function(DOH *node) {
}
/* Now write code to make the function call */
emit_func_call(name,t,l,f);
emit_func_call(node,f);
/* Return value if necessary */
@ -1288,9 +1288,9 @@ void RUBY::cpp_inherit(char **baseclass, int mode) {
*
* --------------------------------------------------------------------- */
void RUBY::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
void RUBY::cpp_memberfunction(DOH *node) {
current = MEMBER_FUNC;
this->Language::cpp_member_func(name, iname, t, l);
this->Language::cpp_memberfunction(node);
current = NO_CPP;
}
@ -1305,9 +1305,9 @@ void RUBY::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
* l - parameters
* -------------------------------------------------------------------- */
void RUBY::cpp_constructor(char *name, char *iname, ParmList *l) {
void RUBY::cpp_constructor(DOH *node) {
current = CONSTRUCTOR;
this->Language::cpp_constructor(name, iname, l);
this->Language::cpp_constructor(node);
current = NO_CPP;
}
@ -1322,9 +1322,13 @@ void RUBY::cpp_constructor(char *name, char *iname, ParmList *l) {
*
* -------------------------------------------------------------------- */
void RUBY::cpp_destructor(char *name, char *newname) {
void RUBY::cpp_destructor(DOH *node) {
char *name, *newname;
name = GetChar(node,"name");
newname = GetChar(node,"scriptname");
current = DESTRUCTOR;
this->Language::cpp_destructor(name, newname);
this->Language::cpp_destructor(node);
String *freefunc = NewString("");
String *freeproto = NewString("");
@ -1374,9 +1378,9 @@ void RUBY::cpp_destructor(char *name, char *newname) {
* This creates a pair of functions to set/get the variable of a member.
* -------------------------------------------------------------------- */
void RUBY::cpp_variable(char *name, char *iname, SwigType *t) {
void RUBY::cpp_variable(DOH *node) {
current = MEMBER_VAR;
this->Language::cpp_variable(name, iname, t);
this->Language::cpp_variable(node);
current = NO_CPP;
}
@ -1392,9 +1396,9 @@ void RUBY::cpp_variable(char *name, char *iname, SwigType *t) {
* l = Parameters
* ---------------------------------------------------------------------- */
void RUBY::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) {
void RUBY::cpp_staticfunction(DOH *node) {
current = STATIC_FUNC;
this->Language::cpp_static_func(name, iname, t, l);
this->Language::cpp_staticfunction(node);
current = NO_CPP;
}
@ -1412,9 +1416,9 @@ void RUBY::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) {
* --------------------------------------------------------------------- */
void RUBY::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) {
void RUBY::cpp_constant(DOH *node) {
current = CLASS_CONST;
this->Language::cpp_declare_const(name, iname, type, value);
this->Language::cpp_constant(node);
current = NO_CPP;
}
@ -1430,9 +1434,9 @@ void RUBY::cpp_declare_const(char *name, char *iname, SwigType *type, char *valu
*
* --------------------------------------------------------------------- */
void RUBY::cpp_static_var(char *name, char *iname, SwigType *t) {
void RUBY::cpp_staticvariable(DOH *node) {
current = STATIC_VAR;
this->Language::cpp_static_var(name, iname, t);
this->Language::cpp_staticvariable(node);
current = NO_CPP;
}

16
Source/Modules1.1/ruby.h
View file

@ -27,21 +27,21 @@ class RUBY : public Language {
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);
virtual void add_native(char *, char *, SwigType *, ParmList *);
virtual void nativefunction(DOH *);
virtual void create_command(char *, char *, int);
virtual void import(char *);
/* C++ language extensions. */
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_constructor(char *name, char *iname, ParmList *l);
virtual void cpp_destructor(char *name, char *newname);
virtual void cpp_memberfunction(DOH *);
virtual void cpp_constructor(DOH *);
virtual void cpp_destructor(DOH *);
virtual void cpp_open_class(char *classname, char *rname, char *ctype, int strip);
virtual void cpp_close_class();
virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL);
virtual void cpp_variable(char *name, char *iname, SwigType *t);
virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value);
virtual void cpp_static_var(char *name, char *iname, SwigType *t);
virtual void cpp_variable(DOH *);
virtual void cpp_staticfunction(DOH *);
virtual void cpp_constant(DOH *);
virtual void cpp_staticvariable(DOH *);
/* Declaration of a class, but not a full definition */
virtual void cpp_class_decl(char *, char *, char *);

37
Source/Modules1.1/tcl8.cxx
View file

@ -292,7 +292,7 @@ TCL8::function(DOH *node) {
0);
/* Print out variables for storing arguments. */
pcount = emit_args(d, l, f);
pcount = emit_args(node, f);
numopt = check_numopt(l);
/* Extract parameters. */
@ -440,7 +440,7 @@ TCL8::function(DOH *node) {
Printv(f->code,incode,0);
/* Now write code to make the function call */
emit_func_call(name,d,l,f);
emit_func_call(node,f);
/* Return value if necessary */
if ((tm = Swig_typemap_lookup((char*)"out",d,name,(char*)"result",(char*)"tcl_result",0))) {
@ -950,11 +950,16 @@ TCL8::usage_string(char *iname, SwigType *, ParmList *l) {
}
/* -----------------------------------------------------------------------------
* TCL8::add_native()
* TCL8::nativefunction();
* ----------------------------------------------------------------------------- */
void
TCL8::add_native(char *name, char *funcname, SwigType *, ParmList *) {
TCL8::nativefunction(DOH *node) {
char *name;
char *funcname;
name = GetChar(node,"scriptname");
funcname = GetChar(node,"name");
Printf(f_init,"\t Tcl_CreateObjCommand(interp, SWIG_prefix \"%s\", %s, (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);\n",name, funcname);
}
@ -1043,13 +1048,16 @@ TCL8::cpp_close_class() {
Delete(code);
}
void TCL8::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
void TCL8::cpp_memberfunction(DOH *node) {
char *name, *iname;
char *realname;
char temp[1024];
String *rname;
this->Language::cpp_member_func(name,iname,t,l);
this->Language::cpp_memberfunction(node);
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
realname = iname ? iname : name;
/* Add stubs for this member to our class handler function */
@ -1061,14 +1069,17 @@ void TCL8::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
}
}
void TCL8::cpp_variable(char *name, char *iname, SwigType *t) {
void TCL8::cpp_variable(DOH *node) {
char *name, *iname;
char *realname;
char temp[1024];
String *rname;
this->Language::cpp_variable(name, iname, t);
this->Language::cpp_variable(node);
if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
realname = iname ? iname : name;
Printv(attributes, tab4, "{ \"-", realname, "\",", 0);
@ -1090,13 +1101,13 @@ void TCL8::cpp_variable(char *name, char *iname, SwigType *t) {
}
void
TCL8::cpp_constructor(char *name, char *iname, ParmList *l) {
this->Language::cpp_constructor(name,iname,l);
TCL8::cpp_constructor(DOH *node) {
this->Language::cpp_constructor(node);
have_constructor = 1;
}
void
TCL8::cpp_destructor(char *name, char *newname) {
this->Language::cpp_destructor(name,newname);
TCL8::cpp_destructor(DOH *node) {
this->Language::cpp_destructor(node);
have_destructor = 1;
}

10
Source/Modules1.1/tcl8.h
View file

@ -33,17 +33,17 @@ public :
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);
virtual void add_native(char *, char *, SwigType *, ParmList *);
virtual void nativefunction(DOH *);
virtual void create_command(char *, char *);
// Stubs for processing C++ classes in Tcl
virtual void cpp_open_class(char *classname, char *rename, char *ctype, int strip);
virtual void cpp_close_class();
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_variable(char *name, char *iname, SwigType *t);
virtual void cpp_constructor(char *name, char *iname, ParmList *l);
virtual void cpp_destructor(char *name, char *newname);
virtual void cpp_memberfunction(DOH *);
virtual void cpp_variable(DOH *);
virtual void cpp_constructor(DOH *);
virtual void cpp_destructor(DOH *);
};

51
Source/SWIG1.1/cplus.cxx
View file

@ -277,9 +277,21 @@ public:
update_parms(l);
update_local_type(t);
if (is_static) {
lang->cpp_static_func(name, iname, t, l);
DOH *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
Setattr(node,"type",t);
Setattr(node,"parms",l);
lang->cpp_staticfunction(node);
Delete(node);
} else {
lang->cpp_member_func(name, iname, t, l);
DOH *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
Setattr(node,"type",t);
Setattr(node,"parms",l);
lang->cpp_memberfunction(node);
Delete(node);
}
Delete(l);
Delete(t);
@ -328,7 +340,12 @@ public:
l = CopyParmList(parms);
update_parms(l);
lang->cpp_constructor(name,iname,l);
Hash *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
Setattr(node,"parms",l);
lang->cpp_constructor(node);
Delete(node);
Delete(l);
}
}
@ -380,7 +397,11 @@ public:
line_number = line;
input_file = file;
ccode = code;
lang->cpp_destructor(name, iname);
Hash *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
lang->cpp_destructor(node);
Delete(node);
}
};
@ -433,9 +454,19 @@ public:
}
if (!is_static) {
lang->cpp_variable(name,iname,t);
DOH *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
Setattr(node,"type",t);
lang->cpp_variable(node);
Delete(node);
} else {
lang->cpp_static_var(name,iname,t);
DOH *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname",iname);
Setattr(node,"type",t);
lang->cpp_staticvariable(node);
Delete(node);
}
Status = old_status;
Delete(t);
@ -495,7 +526,13 @@ public:
line_number = line;
input_file = file;
ccode = code;
lang->cpp_declare_const(name,iname,type,value);
DOH *node = NewHash();
Setattr(node,"name",name);
Setattr(node,"scriptname", iname);
Setattr(node,"type",type);
Setattr(node,"value",value);
lang->cpp_constant(node);
Delete(node);
}
void inherit(int mode) {

32
Source/SWIG1.1/emit.cxx
View file

@ -46,8 +46,10 @@ void new_create_function(char *name, char *iname, SwigType *type, ParmList *l) {
* Returns the number of parameters associated with a function.
* ----------------------------------------------------------------------------- */
int emit_args(SwigType *rt, ParmList *l, Wrapper *f) {
int emit_args(DOH *node, Wrapper *f) {
SwigType *rt;
ParmList *l;
Parm *p;
int i;
char *tm;
@ -56,6 +58,9 @@ int emit_args(SwigType *rt, ParmList *l, Wrapper *f) {
DOHString *pname;
DOHString *lname;
rt = Getattr(node,"type");
l = Getattr(node,"parms");
/* Emit function arguments */
Swig_cargs(f, l);
@ -106,9 +111,16 @@ void emit_set_action(DOHString_or_char *decl) {
fcall = NewString(decl);
}
void emit_func_call(char *decl, SwigType *t, ParmList *l, Wrapper *f) {
void emit_func_call(DOH *node, Wrapper *f) {
char *decl;
SwigType *t;
ParmList *l;
char *tm;
decl = GetChar(node,"name");
t = Getattr(node,"type");
l = Getattr(node,"parms");
if ((tm = Swig_typemap_lookup((char*)"except",t,decl,(char*)"result",(char*)"",0))) {
Printv(f->code,tm,0);
Replace(f->code,"$name",decl,DOH_REPLACE_ANY);
@ -131,7 +143,7 @@ void emit_func_call(char *decl, SwigType *t, ParmList *l, Wrapper *f) {
}
/* -----------------------------------------------------------------------------
* void emit_set_get(char *name, char *iname, DataType *type)
* void emit_set_get()
*
* Emits a pair of functions to set/get the value of a variable. This is
* only used in the event the target language can't provide variable linking
@ -167,12 +179,17 @@ strcpy((char *)$target,$source);\n\
return ($ltype) $target;\n;";
void emit_set_get(char *name, char *iname, SwigType *t) {
void emit_set_get(DOH *node) {
char *name, *iname;
SwigType *t;
Wrapper *w;
DOHString *new_iname;
char *code = 0;
name = GetChar(node,"name");
iname = GetChar(node,"iname");
t = Getattr(node,"type");
/* First write a function to set the variable of the variable */
if (!(Status & STAT_READONLY)) {
@ -235,3 +252,6 @@ int check_numopt(ParmList *p) {

76
Source/SWIG1.1/lang.cxx
View file

@ -33,12 +33,12 @@ void Language::create_command(char *, char *) {
}
/* -----------------------------------------------------------------
* Language::add_native()
* Language::nativefunction()
* ----------------------------------------------------------------- */
void
Language::add_native(char *, char *iname, SwigType *, ParmList *) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, iname);
Language::nativefunction(DOH *node) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, Getattr(node,"scriptname"));
}
static char *ClassName = 0; /* This is the real name of the current class */
@ -84,13 +84,21 @@ void Language::cpp_close_class() {
}
/* -----------------------------------------------------------------------------
* Language::cpp_member_func()
* Language::cpp_memberfunction()
* ----------------------------------------------------------------------------- */
void Language::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
void Language::cpp_memberfunction(DOH *node) {
char *name, *iname;
SwigType *t;
ParmList *l;
char new_name[256];
char *prefix;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
/* Generate the C wrapper function name and interpreter name of this function*/
/* Set the classname prefix */
@ -121,10 +129,15 @@ void Language::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l
* Language::cpp_constructor()
* ----------------------------------------------------------------------------- */
void Language::cpp_constructor(char *name, char *iname, ParmList *l) {
void Language::cpp_constructor(DOH *node) {
char *name, *iname;
ParmList *l;
char *prefix, *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
l = Getattr(node,"parms");
if ((strcmp(name,ClassName)) && (!ObjCClass)) {
Printf(stderr,"%s : Line %d. Function %s must have a return type.\n",
input_file, line_number, name);
@ -161,10 +174,12 @@ void Language::cpp_constructor(char *name, char *iname, ParmList *l) {
* Language::cpp_destructor()
* ----------------------------------------------------------------------------- */
void Language::cpp_destructor(char *name, char *iname) {
void Language::cpp_destructor(DOH *node) {
char *name, *iname;
char *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
if (ClassRename)
cname = Char(Swig_name_destroy(ClassRename));
else
@ -215,9 +230,15 @@ void Language::cpp_inherit(char **baseclass, int mode) {
* Language::cpp_variable()
* ----------------------------------------------------------------------------- */
void Language::cpp_variable(char *name, char *iname, SwigType *t) {
void Language::cpp_variable(DOH *node) {
char *name, *iname;
SwigType *t;
char *prefix, *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
/* Set the class prefix */
if (ClassRename) {
@ -254,12 +275,19 @@ void Language::cpp_variable(char *name, char *iname, SwigType *t) {
* Language::cpp_static_func()
* ----------------------------------------------------------------------------- */
void Language::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) {
void Language::cpp_staticfunction(DOH *node) {
char *name, *iname;
SwigType *t;
ParmList *l;
char *prefix;
char *mname;
char *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
/* Set the classname prefix */
if (ClassRename)
@ -292,17 +320,24 @@ void Language::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l
}
/* -----------------------------------------------------------------------------
* Language::cpp_declare_const()
* Language::cpp_constant()
* ----------------------------------------------------------------------------- */
void Language::cpp_declare_const(char *name, char *iname, SwigType *type, char *value)
void Language::cpp_constant(DOH *node)
{
char *name, *iname, *value;
SwigType *type;
char *cname;
char mname[256];
char *new_value;
char *prefix;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
value = GetChar(node,"value");
type = Getattr(node,"type");
/* Set the classname prefix */
if (ClassRename) {
@ -352,15 +387,20 @@ void Language::cpp_declare_const(char *name, char *iname, SwigType *type, char *
}
/* -----------------------------------------------------------------------------
* Language::cpp_static_var()
* Language::cpp_staticvariable()
* ----------------------------------------------------------------------------- */
void Language::cpp_static_var(char *name, char *iname, SwigType *t) {
void Language::cpp_staticvariable(DOH *node) {
char *name, *iname;
SwigType *t;
char *cname;
char mname[256];
char *prefix;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
/* Set the classname prefix */
if (ClassRename) {

14
Source/SWIG1.1/parser.yxx
View file

@ -790,7 +790,11 @@ statement : INCLUDE LPAREN STRING RPAREN STRING LBRACE {
Printf(stderr,"%s : Line %d. Name of native function %s conflicts with previous declaration (ignored)\n",
input_file, line_number, $3);
} else {
lang->add_native($3,$6,0,0);
DOH *node = NewHash();
Setattr(node,"scriptname",$3);
Setattr(node,"name",$6);
lang->nativefunction(node);
Delete(node);
}
}
}
@ -805,7 +809,13 @@ statement : INCLUDE LPAREN STRING RPAREN STRING LBRACE {
if ($5) {
emit_extern_func($7.id, $6, $9, $5, f_header);
}
lang->add_native($3,$7.id,$6,$9);
DOH *node = NewHash();
Setattr(node,"name",$7.id);
Setattr(node,"scriptname",$3);
Setattr(node,"type",$6);
Setattr(node,"parms",$9);
lang->nativefunction(node);
Delete(node);
}
}
Delete($6);

2
Source/SWIG1.1/scanner.cxx
View file

@ -80,6 +80,7 @@ void scanner_file(DOHFile *f) {
in = (InFile *) malloc(sizeof(InFile));
in->f = f;
in->in_file = input_file;
in->line_number = 1;
in->extern_mode = WrapExtern;
in->force_extern = ForceExtern;
in->inline_mode = 0;
@ -177,6 +178,7 @@ void retract(int n) {
void start_inline(char *text, int line) {
InFile *in;
in_head->line_number = line_number;
in = (InFile *) malloc(sizeof(InFile));
in->f = NewString(text);
Seek(in->f,0,SEEK_SET);

50
Source/SWIG1.1/swig11.h
View file

@ -92,37 +92,35 @@ class Language {
public:
virtual void parse_args(int argc, char *argv[]) = 0;
virtual void parse() = 0;
/* NEW API */
virtual void function(DOH *node) = 0;
virtual void variable(DOH *node) = 0;
virtual void constant(DOH *node) = 0;
virtual void nativefunction(DOH *node);
/* C++ handling */
virtual void cpp_memberfunction(DOH *node);
virtual void cpp_constructor(DOH *node);
virtual void cpp_destructor(DOH *node);
virtual void cpp_variable(DOH *node);
virtual void cpp_staticfunction(DOH *node);
virtual void cpp_constant(DOH *node);
virtual void cpp_staticvariable(DOH *node);
/* OLD API */
virtual void initialize(void) = 0;
virtual void close(void) = 0;
virtual void set_module(char *mod_name) = 0;
virtual void add_native(char *name, char *iname, SwigType *t, ParmList *l);
virtual void add_typedef(SwigType *t, char *name);
virtual void create_command(char *cname, char *iname);
//
// C++ language extensions.
// You can redefine these, or use the defaults below
//
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_constructor(char *name, char *iname, ParmList *l);
virtual void cpp_destructor(char *name, char *newname);
virtual void cpp_open_class(char *name, char *rename, char *ctype, int strip);
virtual void cpp_close_class();
virtual void cpp_cleanup();
virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL);
virtual void cpp_variable(char *name, char *iname, SwigType *t);
virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l);
virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value);
virtual void cpp_static_var(char *name, char *iname, SwigType *t);
virtual void cpp_pragma(Pragma *plist);
// Pragma directive
virtual void pragma(char *, char *, char *);
// Declaration of a class, but not a full definition
@ -130,7 +128,6 @@ public:
virtual void cpp_class_decl(char *, char *, char *);
// Import directive
virtual void import(char *filename);
};
@ -138,8 +135,7 @@ public:
/* Emit functions */
extern void new_create_function(char *, char *, SwigType *, ParmList *);
extern void emit_func_call(char *, SwigType *, ParmList *, FILE *);
extern void emit_set_get(char *, char *, SwigType *);
extern void emit_set_get(DOH *node);
extern void emit_set_action(DOHString_or_char *decl);
extern int SWIG_main(int, char **, Language *);
@ -160,10 +156,18 @@ extern "C" {
// Misc
extern int emit_args(SwigType *, ParmList *, Wrapper *f);
extern void emit_func_call(char *, SwigType *, ParmList *, Wrapper *f);
extern int emit_args(DOH *node, Wrapper *f);
extern void emit_func_call(DOH *node, Wrapper *f);
extern void SWIG_exit(int); /* use EXIT_{SUCCESS,FAILURE} */
extern int check_numopt(ParmList *);
extern void SWIG_config_file(const String_or_char *);
extern int check_numopt(ParmList *);
extern void SWIG_config_file(const String_or_char *);
/* swig11.h ends here */