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@927 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-10-20 03:49:32 +00:00
commit 60b65c6466
17 changed files with 354 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

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

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

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

80
SWIG/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); 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); numopt = check_numopt(l);
Wrapper_add_local(f,"argvi","int argvi = 0"); Wrapper_add_local(f,"argvi","int argvi = 0");
@ -650,7 +650,7 @@ PERL5::function(DOH *node)
/* Now write code to make the function call */ /* 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))) { if ((tm = Swig_typemap_lookup((char*)"out",d,iname,(char*)"result",(char*)"ST(argvi)",0))) {
Printf(f->code, "%s\n", tm); Printf(f->code, "%s\n", tm);
@ -1275,10 +1275,13 @@ PERL5::usage_func(char *iname, SwigType *, ParmList *l) {
} }
/* ----------------------------------------------------------------------------- /* -----------------------------------------------------------------------------
* PERL5::add_native() * PERL5::nativefunction()
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void 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); Printf(f_init,"\t newXS(\"%s::%s\", %s, file);\n", package,name, funcname);
if (export_all) if (export_all)
Printf(exported,"%s ",name); Printf(exported,"%s ",name);
@ -1495,7 +1498,10 @@ PERL5::cpp_close_class() {
* PERL5::cpp_member_func() * PERL5::cpp_member_func()
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void 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; String *func;
char *realname; char *realname;
Parm *p; Parm *p;
@ -1506,10 +1512,15 @@ PERL5::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
int need_wrapper = 0; int need_wrapper = 0;
member_func = 1; member_func = 1;
this->Language::cpp_member_func(name,iname,t,l); this->Language::cpp_memberfunction(node);
member_func = 0; member_func = 0;
if (!blessed) return; if (!blessed) return;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
func = NewString(""); func = NewString("");
cname = NewString("perl5:"); 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. * 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; char *realname;
String *cname; 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 */ /* Emit a pair of get/set functions for the variable */
member_func = 1; member_func = 1;
this->Language::cpp_variable(name, iname, t); this->Language::cpp_variable(node);
member_func = 0; member_func = 0;
if (iname) realname = iname;
else realname = name;
if (blessed) { 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); Printf(cname,"%s::%s", class_name, realname);
if (Getattr(symbols,cname)) { if (Getattr(symbols,cname)) {
Delete(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 * something that wasn't necessarily allocated by malloc or new
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
PERL5::cpp_constructor(char *name, char *iname, ParmList *l) { PERL5::cpp_constructor(DOH *node) {
char *name, *iname;
ParmList *l;
Parm *p; Parm *p;
int i; int i;
String *realname; String *realname;
@ -1695,10 +1714,12 @@ PERL5::cpp_constructor(char *name, char *iname, ParmList *l) {
/* Emit an old-style constructor for this class */ /* Emit an old-style constructor for this class */
member_func = 1; member_func = 1;
this->Language::cpp_constructor(name, iname, l); this->Language::cpp_constructor(node);
if (blessed) { if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
l = Getattr(node,"parms");
if (iname) if (iname)
realname = iname; realname = iname;
else { else {
@ -1769,12 +1790,16 @@ PERL5::cpp_constructor(char *name, char *iname, ParmList *l) {
* PERL5::cpp_destructor() * PERL5::cpp_destructor()
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void void
PERL5::cpp_destructor(char *name, char *newname) { PERL5::cpp_destructor(DOH *node) {
String *realname; String *realname;
char *name, *newname;
member_func = 1; member_func = 1;
this->Language::cpp_destructor(name, newname); this->Language::cpp_destructor(node);
if (blessed) { if (blessed) {
name = GetChar(node,"name");
newname = GetChar(node,"scriptname");
if (newname) realname = newname; if (newname) realname = newname;
else { else {
if (class_renamed) realname = class_name; 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 void
PERL5::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) { PERL5::cpp_staticfunction(DOH *node) {
this->Language::cpp_static_func(name,iname,t,l); char *name, *iname;
this->Language::cpp_staticfunction(node);
char *realname; char *realname;
if (iname) realname = name;
else realname = iname;
if (blessed) { 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); 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 void
PERL5::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) { PERL5::cpp_constant(DOH *node) {
char *name, *iname;
String *realname; String *realname;
int oldblessed = blessed; int oldblessed = blessed;
char cname[256]; char cname[256];
/* Create a normal constant */ /* Create a normal constant */
blessed = 0; blessed = 0;
this->Language::cpp_declare_const(name, iname, type, value); this->Language::cpp_constant(node);
blessed = oldblessed; blessed = oldblessed;
if (blessed) { if (blessed) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
if (!iname) if (!iname)
realname = name; realname = name;
else else

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

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

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

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

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

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

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

@ -347,11 +347,11 @@ void RUBY::close(void) {
} }
/* -------------------------------------------------------------------------- /* --------------------------------------------------------------------------
* RUBY::add_native() * RUBY::nativefunction()
* -------------------------------------------------------------------------- */ * -------------------------------------------------------------------------- */
void void
RUBY::add_native(char *name, char *funcname, SwigType *, ParmList *) { RUBY::nativefunction(DOH *node) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, funcname); 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 */ /* Ruby needs no destructor wrapper */
if (current == DESTRUCTOR) { if (current == DESTRUCTOR) {
Wrapper *dummy = NewWrapper(); Wrapper *dummy = NewWrapper();
emit_func_call(name,t,l,dummy); emit_func_call(node,dummy);
DelWrapper(dummy); DelWrapper(dummy);
return; 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 */ /* Emit count to check the number of arguments */
if (vararg) { if (vararg) {
@ -621,7 +621,7 @@ void RUBY::function(DOH *node) {
} }
/* Now write code to make the function call */ /* Now write code to make the function call */
emit_func_call(name,t,l,f); emit_func_call(node,f);
/* Return value if necessary */ /* 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; current = MEMBER_FUNC;
this->Language::cpp_member_func(name, iname, t, l); this->Language::cpp_memberfunction(node);
current = NO_CPP; current = NO_CPP;
} }
@ -1305,9 +1305,9 @@ void RUBY::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
* l - parameters * l - parameters
* -------------------------------------------------------------------- */ * -------------------------------------------------------------------- */
void RUBY::cpp_constructor(char *name, char *iname, ParmList *l) { void RUBY::cpp_constructor(DOH *node) {
current = CONSTRUCTOR; current = CONSTRUCTOR;
this->Language::cpp_constructor(name, iname, l); this->Language::cpp_constructor(node);
current = NO_CPP; 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; current = DESTRUCTOR;
this->Language::cpp_destructor(name, newname); this->Language::cpp_destructor(node);
String *freefunc = NewString(""); String *freefunc = NewString("");
String *freeproto = 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. * 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; current = MEMBER_VAR;
this->Language::cpp_variable(name, iname, t); this->Language::cpp_variable(node);
current = NO_CPP; current = NO_CPP;
} }
@ -1392,9 +1396,9 @@ void RUBY::cpp_variable(char *name, char *iname, SwigType *t) {
* l = Parameters * l = Parameters
* ---------------------------------------------------------------------- */ * ---------------------------------------------------------------------- */
void RUBY::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) { void RUBY::cpp_staticfunction(DOH *node) {
current = STATIC_FUNC; current = STATIC_FUNC;
this->Language::cpp_static_func(name, iname, t, l); this->Language::cpp_staticfunction(node);
current = NO_CPP; 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; current = CLASS_CONST;
this->Language::cpp_declare_const(name, iname, type, value); this->Language::cpp_constant(node);
current = NO_CPP; 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; current = STATIC_VAR;
this->Language::cpp_static_var(name, iname, t); this->Language::cpp_staticvariable(node);
current = NO_CPP; current = NO_CPP;
} }

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

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

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

@ -292,7 +292,7 @@ TCL8::function(DOH *node) {
0); 0);
/* Print out variables for storing arguments. */ /* Print out variables for storing arguments. */
pcount = emit_args(d, l, f); pcount = emit_args(node, f);
numopt = check_numopt(l); numopt = check_numopt(l);
/* Extract parameters. */ /* Extract parameters. */
@ -440,7 +440,7 @@ TCL8::function(DOH *node) {
Printv(f->code,incode,0); Printv(f->code,incode,0);
/* Now write code to make the function call */ /* Now write code to make the function call */
emit_func_call(name,d,l,f); emit_func_call(node,f);
/* Return value if necessary */ /* Return value if necessary */
if ((tm = Swig_typemap_lookup((char*)"out",d,name,(char*)"result",(char*)"tcl_result",0))) { 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 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); 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); 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 *realname;
char temp[1024]; char temp[1024];
String *rname; String *rname;
this->Language::cpp_member_func(name,iname,t,l); this->Language::cpp_memberfunction(node);
if (shadow) { if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
realname = iname ? iname : name; realname = iname ? iname : name;
/* Add stubs for this member to our class handler function */ /* 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 *realname;
char temp[1024]; char temp[1024];
String *rname; String *rname;
this->Language::cpp_variable(name, iname, t); this->Language::cpp_variable(node);
if (shadow) { if (shadow) {
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
realname = iname ? iname : name; realname = iname ? iname : name;
Printv(attributes, tab4, "{ \"-", realname, "\",", 0); Printv(attributes, tab4, "{ \"-", realname, "\",", 0);
@ -1090,13 +1101,13 @@ void TCL8::cpp_variable(char *name, char *iname, SwigType *t) {
} }
void void
TCL8::cpp_constructor(char *name, char *iname, ParmList *l) { TCL8::cpp_constructor(DOH *node) {
this->Language::cpp_constructor(name,iname,l); this->Language::cpp_constructor(node);
have_constructor = 1; have_constructor = 1;
} }
void void
TCL8::cpp_destructor(char *name, char *newname) { TCL8::cpp_destructor(DOH *node) {
this->Language::cpp_destructor(name,newname); this->Language::cpp_destructor(node);
have_destructor = 1; have_destructor = 1;
} }

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

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

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

@ -277,9 +277,21 @@ public:
update_parms(l); update_parms(l);
update_local_type(t); update_local_type(t);
if (is_static) { 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 { } 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(l);
Delete(t); Delete(t);
@ -328,7 +340,12 @@ public:
l = CopyParmList(parms); l = CopyParmList(parms);
update_parms(l); 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); Delete(l);
} }
} }
@ -380,7 +397,11 @@ public:
line_number = line; line_number = line;
input_file = file; input_file = file;
ccode = code; 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) { 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 { } 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; Status = old_status;
Delete(t); Delete(t);
@ -495,7 +526,13 @@ public:
line_number = line; line_number = line;
input_file = file; input_file = file;
ccode = code; 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) { void inherit(int mode) {

32
SWIG/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. * 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; Parm *p;
int i; int i;
char *tm; char *tm;
@ -56,6 +58,9 @@ int emit_args(SwigType *rt, ParmList *l, Wrapper *f) {
DOHString *pname; DOHString *pname;
DOHString *lname; DOHString *lname;
rt = Getattr(node,"type");
l = Getattr(node,"parms");
/* Emit function arguments */ /* Emit function arguments */
Swig_cargs(f, l); Swig_cargs(f, l);
@ -106,9 +111,16 @@ void emit_set_action(DOHString_or_char *decl) {
fcall = NewString(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; 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))) { if ((tm = Swig_typemap_lookup((char*)"except",t,decl,(char*)"result",(char*)"",0))) {
Printv(f->code,tm,0); Printv(f->code,tm,0);
Replace(f->code,"$name",decl,DOH_REPLACE_ANY); 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 * 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 * 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;"; 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; Wrapper *w;
DOHString *new_iname; DOHString *new_iname;
char *code = 0; 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 */ /* First write a function to set the variable of the variable */
if (!(Status & STAT_READONLY)) { if (!(Status & STAT_READONLY)) {
@ -235,3 +252,6 @@ int check_numopt(ParmList *p) {

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

@ -33,12 +33,12 @@ void Language::create_command(char *, char *) {
} }
/* ----------------------------------------------------------------- /* -----------------------------------------------------------------
* Language::add_native() * Language::nativefunction()
* ----------------------------------------------------------------- */ * ----------------------------------------------------------------- */
void void
Language::add_native(char *, char *iname, SwigType *, ParmList *) { Language::nativefunction(DOH *node) {
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, iname); 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 */ 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 new_name[256];
char *prefix; 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*/ /* Generate the C wrapper function name and interpreter name of this function*/
/* Set the classname prefix */ /* Set the classname prefix */
@ -121,10 +129,15 @@ void Language::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l
* Language::cpp_constructor() * 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; char *prefix, *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
l = Getattr(node,"parms");
if ((strcmp(name,ClassName)) && (!ObjCClass)) { if ((strcmp(name,ClassName)) && (!ObjCClass)) {
Printf(stderr,"%s : Line %d. Function %s must have a return type.\n", Printf(stderr,"%s : Line %d. Function %s must have a return type.\n",
input_file, line_number, name); input_file, line_number, name);
@ -161,10 +174,12 @@ void Language::cpp_constructor(char *name, char *iname, ParmList *l) {
* Language::cpp_destructor() * Language::cpp_destructor()
* ----------------------------------------------------------------------------- */ * ----------------------------------------------------------------------------- */
void Language::cpp_destructor(char *name, char *iname) { void Language::cpp_destructor(DOH *node) {
char *name, *iname;
char *cname; char *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
if (ClassRename) if (ClassRename)
cname = Char(Swig_name_destroy(ClassRename)); cname = Char(Swig_name_destroy(ClassRename));
else else
@ -215,9 +230,15 @@ void Language::cpp_inherit(char **baseclass, int mode) {
* Language::cpp_variable() * 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; char *prefix, *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
/* Set the class prefix */ /* Set the class prefix */
if (ClassRename) { if (ClassRename) {
@ -254,12 +275,19 @@ void Language::cpp_variable(char *name, char *iname, SwigType *t) {
* Language::cpp_static_func() * 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 *prefix;
char *mname; char *mname;
char *cname; char *cname;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
/* Set the classname prefix */ /* Set the classname prefix */
if (ClassRename) 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 *cname;
char mname[256]; char mname[256];
char *new_value; char *new_value;
char *prefix; char *prefix;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
value = GetChar(node,"value");
type = Getattr(node,"type");
/* Set the classname prefix */ /* Set the classname prefix */
if (ClassRename) { 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 *cname;
char mname[256]; char mname[256];
char *prefix; char *prefix;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
/* Set the classname prefix */ /* Set the classname prefix */
if (ClassRename) { if (ClassRename) {

14
SWIG/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", Printf(stderr,"%s : Line %d. Name of native function %s conflicts with previous declaration (ignored)\n",
input_file, line_number, $3); input_file, line_number, $3);
} else { } 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) { if ($5) {
emit_extern_func($7.id, $6, $9, $5, f_header); 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); Delete($6);

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

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

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

@ -92,37 +92,35 @@ class Language {
public: public:
virtual void parse_args(int argc, char *argv[]) = 0; virtual void parse_args(int argc, char *argv[]) = 0;
virtual void parse() = 0; virtual void parse() = 0;
/* NEW API */
virtual void function(DOH *node) = 0; virtual void function(DOH *node) = 0;
virtual void variable(DOH *node) = 0; virtual void variable(DOH *node) = 0;
virtual void constant(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 initialize(void) = 0;
virtual void close(void) = 0; virtual void close(void) = 0;
virtual void set_module(char *mod_name) = 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 add_typedef(SwigType *t, char *name);
virtual void create_command(char *cname, char *iname); 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_open_class(char *name, char *rename, char *ctype, int strip);
virtual void cpp_close_class(); virtual void cpp_close_class();
virtual void cpp_cleanup(); virtual void cpp_cleanup();
virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); 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); virtual void cpp_pragma(Pragma *plist);
// Pragma directive
virtual void pragma(char *, char *, char *); virtual void pragma(char *, char *, char *);
// Declaration of a class, but not a full definition // Declaration of a class, but not a full definition
@ -130,7 +128,6 @@ public:
virtual void cpp_class_decl(char *, char *, char *); virtual void cpp_class_decl(char *, char *, char *);
// Import directive // Import directive
virtual void import(char *filename); virtual void import(char *filename);
}; };
@ -138,8 +135,7 @@ public:
/* Emit functions */ /* Emit functions */
extern void new_create_function(char *, char *, SwigType *, ParmList *); extern void new_create_function(char *, char *, SwigType *, ParmList *);
extern void emit_func_call(char *, SwigType *, ParmList *, FILE *); extern void emit_set_get(DOH *node);
extern void emit_set_get(char *, char *, SwigType *);
extern void emit_set_action(DOHString_or_char *decl); extern void emit_set_action(DOHString_or_char *decl);
extern int SWIG_main(int, char **, Language *); extern int SWIG_main(int, char **, Language *);
@ -160,10 +156,18 @@ extern "C" {
// Misc // Misc
extern int emit_args(SwigType *, ParmList *, Wrapper *f); extern int emit_args(DOH *node, Wrapper *f);
extern void emit_func_call(char *, SwigType *, ParmList *, Wrapper *f); extern void emit_func_call(DOH *node, Wrapper *f);
extern void SWIG_exit(int); /* use EXIT_{SUCCESS,FAILURE} */ extern void SWIG_exit(int); /* use EXIT_{SUCCESS,FAILURE} */
extern int check_numopt(ParmList *); extern int check_numopt(ParmList *);
extern void SWIG_config_file(const String_or_char *); extern void SWIG_config_file(const String_or_char *);
/* swig11.h ends here */ /* swig11.h ends here */