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

Started conversion of Language API

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@925 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-10-18 05:06:39 +00:00
commit eb1b332e4c
19 changed files with 307 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -461,15 +461,15 @@ throw_unhandled_guile_type_error (SwigType *d)
}
// ----------------------------------------------------------------------
// GUILE::create_function(char *name, char *iname, SwigType *d,
// ParmList *l)
//
// GUILE::create_function()
// Create a function declaration and register it with the interpreter.
// ----------------------------------------------------------------------
void
GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
{
GUILE::function (DOH *node) {
char *name, *iname;
SwigType *d;
ParmList *l;
Parm *p;
DOHString *proc_name = 0;
char source[256], target[256];
@ -484,6 +484,11 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
int numargs = 0;
int numopt = 0;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
d = Getattr(node,"type");
l = Getattr(node,"parms");
// Make a wrapper name for this
char * wname = new char [strlen (prefix) + strlen (iname) + 2];
sprintf (wname, "%s%s", prefix, iname);
@ -722,7 +727,7 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
}
// -----------------------------------------------------------------------
// GUILE::link_variable(char *name, char *iname, SwigType *d)
// GUILE::variable()
//
// Create a link to a C variable.
// This creates a single function PREFIX_var_VARNAME().
@ -733,13 +738,21 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
// -----------------------------------------------------------------------
void
GUILE::link_variable (char *name, char *iname, SwigType *t)
GUILE::variable (DOH *node)
{
char *name, *iname;
SwigType *t;
DOHString *proc_name;
char var_name[256];
char *tm;
Wrapper *f;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
f = NewWrapper();
// evaluation function names
@ -879,15 +892,18 @@ GUILE::link_variable (char *name, char *iname, SwigType *t)
}
// -----------------------------------------------------------------------
// GUILE::declare_const(char *name, char *iname, SwigType *type, char *value)
// GUILE::constant()
//
// Makes a constant. Not sure how this is really supposed to work.
// I'm going to fake out SWIG and create a variable instead.
// ------------------------------------------------------------------------
void
GUILE::declare_const (char *name, char *, SwigType *type, char *value)
GUILE::constant(DOH *node)
{
char *name;
SwigType *type;
char *value;
int OldStatus = Status; // Save old status flags
DOHString *proc_name;
char var_name[256];
@ -895,6 +911,10 @@ GUILE::declare_const (char *name, char *, SwigType *type, char *value)
char *tm;
Wrapper *f;
name = GetChar(node,"name");
type = Getattr(node,"type");
value = GetChar(node,"value");
f = NewWrapper();
Status = STAT_READONLY; // Enable readonly mode.
@ -937,7 +957,10 @@ GUILE::declare_const (char *name, char *, SwigType *type, char *value)
}
// Now create a variable declaration
link_variable (var_name, name, type);
Hash *nnode = Copy(node);
Setattr(nnode,"name",var_name);
variable(nnode);
Delete(nnode);
Status = OldStatus;
}
Delete(proc_name);

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

@ -44,9 +44,9 @@ public :
GUILE ();
void parse_args (int, char *argv[]);
void parse ();
void create_function (char *, char *, SwigType *, ParmList *);
void link_variable (char *, char *, SwigType *);
void declare_const (char *, char *, SwigType *, char *);
void function (DOH *node);
void variable (DOH *node);
void constant (DOH *node);
void initialize ();
void headers (void);
void close (void);

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

@ -240,8 +240,7 @@ MZSCHEME::get_pointer (String *name, int parm, SwigType *t, Wrapper *f)
"\", \"", SwigType_manglestr(t), "\", ", p, ", argc, argv);\n",0);
}
// ----------------------------------------------------------------------
// MZSCHEME::create_function(char *name, char *iname, SwigType *d,
// ParmList *l)
// MZSCHEME::create_function()
//
// Create a function declaration and register it with the interpreter.
// ----------------------------------------------------------------------
@ -267,8 +266,11 @@ throw_unhandled_mzscheme_type_error (SwigType *d)
}
void
MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
MZSCHEME::function(DOH *node)
{
char *name, *iname;
SwigType *d;
ParmList *l;
Parm *p;
Wrapper *f = NewWrapper();
String *proc_name = NewString("");
@ -287,6 +289,11 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
int argout_set = 0;
int i = 0;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
d = Getattr(node,"type");
l = Getattr(node,"parms");
// Make a wrapper name for this
char *wname = Char(Swig_name_wrapper(iname));
@ -476,7 +483,7 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
}
// -----------------------------------------------------------------------
// MZSCHEME::link_variable(char *name, char *iname, SwigType *d)
// MZSCHEME::variable()
//
// Create a link to a C variable.
// This creates a single function _wrap_swig_var_varname().
@ -487,8 +494,10 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
// -----------------------------------------------------------------------
void
MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
MZSCHEME::variable (DOH *node)
{
char *name, *iname;
SwigType *t;
String *proc_name = NewString("");
char var_name[256];
char *tm;
@ -496,6 +505,10 @@ MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
String *argnum = NewString("0");
String *arg = NewString("argv[0]");
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
// evaluation function names
sprintf (var_name, "_wrap_%svar_%s", prefix, iname);
@ -604,15 +617,19 @@ MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
}
// -----------------------------------------------------------------------
// MZSCHEME::declare_const(char *name, char *iname, SwigType *type, char *value)
// MZSCHEME::constant()
//
// Makes a constant. Not sure how this is really supposed to work.
// I'm going to fake out SWIG and create a variable instead.
// ------------------------------------------------------------------------
void
MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
MZSCHEME::constant(DOH *node)
{
char *name;
SwigType *type;
char *value;
int OldStatus = Status; // Save old status flags
char var_name[256];
String *proc_name = NewString("");
@ -620,6 +637,10 @@ MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
String *temp = NewString("");
char *tm;
name = GetChar(node,"name");
type = Getattr(node,"type");
value = GetChar(node,"value");
Status = STAT_READONLY; // Enable readonly mode.
// Make a static variable;
@ -666,7 +687,10 @@ MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
// Now create a variable declaration
link_variable (var_name, name, type);
Hash *nnode = Copy(node);
Setattr(nnode,"name",var_name);
variable (nnode);
Delete(nnode);
Status = OldStatus;
}
Delete(proc_name);

6
Source/Modules1.1/mzscheme.h
View file

@ -35,9 +35,9 @@ private:
public :
void parse_args (int, char *argv[]);
void parse ();
void create_function (char *, char *, SwigType *, ParmList *);
void link_variable (char *, char *, SwigType *);
void declare_const (char *, char *, SwigType *, char *);
void function (DOH *node);
void variable (DOH *node);
void constant (DOH *node);
void initialize ();
void headers (void);
void close (void);

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

@ -498,8 +498,11 @@ PERL5::create_command(char *cname, char *iname) {
* PERL5::create_function()
* ----------------------------------------------------------------------------- */
void
PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
PERL5::function(DOH *node)
{
char *name, *iname;
SwigType *d;
ParmList *l;
Parm *p;
int pcount,i,j;
Wrapper *f;
@ -509,6 +512,11 @@ PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
int numopt = 0;
int need_save, num_saved = 0;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
d = Getattr(node,"type");
l = Getattr(node,"parms");
f = NewWrapper();
cleanup = NewString("");
outarg = NewString("");
@ -843,14 +851,20 @@ PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
* PERL5::link_variable()
* ----------------------------------------------------------------------------- */
void PERL5::link_variable(char *name, char *iname, SwigType *t)
{
void PERL5::variable(DOH *node) {
char *name, *iname;
SwigType *t;
char set_name[256];
char val_name[256];
Wrapper *getf, *setf;
char *tm;
int setable = 1;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
sprintf(set_name,"_wrap_set_%s",iname);
sprintf(val_name,"_wrap_val_%s",iname);
@ -1073,7 +1087,7 @@ void PERL5::link_variable(char *name, char *iname, SwigType *t)
}
/* -----------------------------------------------------------------------------
* PERL5::declare_const()
* PERL5::constant()
* ----------------------------------------------------------------------------- */
/* Functions used to create constants */
@ -1131,15 +1145,21 @@ static const char *setrv = "#ifndef PERL_OBJECT\
\n}\n";
void
PERL5::declare_const(char *name, char *, SwigType *type, char *value)
PERL5::constant(DOH *node)
{
char *name;
SwigType *type;
char *value;
char *tm;
static int have_int_func = 0;
static int have_double_func = 0;
static int have_char_func = 0;
static int have_ref_func = 0;
name = GetChar(node,"name");
type = Getattr(node,"type");
value = GetChar(node,"value");
if ((tm = Swig_typemap_lookup((char*)"const",type,name,value,name,0))) {
Printf(f_init,"%s\n",tm);
} else {

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

@ -25,9 +25,9 @@ private:
public :
virtual void parse_args(int, char *argv[]);
virtual void parse();
virtual void create_function(char *, char *, SwigType *, ParmList *);
virtual void link_variable(char *, char *, SwigType *);
virtual void declare_const(char *, char *, SwigType *, char *);
virtual void function(DOH *node);
virtual void variable(DOH *node);
virtual void constant(DOH *node);
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);

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

@ -322,7 +322,11 @@ PYTHON::create_command(char *cname, char *iname) {
* PYTHON::create_function()
* ----------------------------------------------------------------------------- */
void
PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
PYTHON::function(DOH *node) {
char *name;
char *iname;
SwigType *d;
ParmList *l;
Parm *p;
int pcount,i,j;
char wname[256];
@ -339,6 +343,10 @@ PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
char *tm;
int numopt = 0;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
d = Getattr(node,"type");
l = Getattr(node,"parms");
f = NewWrapper();
parse_args = NewString("");
arglist = NewString("");
@ -670,15 +678,21 @@ PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
}
/* -----------------------------------------------------------------------------
* PYTHON::link_variable()
* PYTHON::variable()
* ----------------------------------------------------------------------------- */
void
PYTHON::link_variable(char *name, char *iname, SwigType *t) {
PYTHON::variable(DOH *node) {
char *name, *iname;
SwigType *t;
char *wname;
static int have_globals = 0;
char *tm;
Wrapper *getf, *setf;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
getf = NewWrapper();
setf = NewWrapper();
@ -908,12 +922,19 @@ PYTHON::link_variable(char *name, char *iname, SwigType *t) {
}
/* -----------------------------------------------------------------------------
* PYTHON::declare_const()
* PYTHON::constant()
* ----------------------------------------------------------------------------- */
void
PYTHON::declare_const(char *name, char *, SwigType *type, char *value) {
PYTHON::constant(DOH *node) {
char *name;
SwigType *type;
char *value;
char *tm;
name = GetChar(node,"name");
type = Getattr(node,"type");
value = GetChar(node,"value");
if ((tm = Swig_typemap_lookup((char*)"const",type,name,value,name,0))) {
Printf(const_code,"%s\n", tm);
} else {

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

@ -33,9 +33,9 @@ public :
// Don't change any of this
virtual void parse_args(int, char *argv[]);
virtual void parse();
virtual void create_function(char *, char *, SwigType *, ParmList *);
virtual void link_variable(char *, char *, SwigType *);
virtual void declare_const(char *, char *, SwigType *, char *);
virtual void function(DOH *node);
virtual void variable(DOH *node);
virtual void constant(DOH *node);
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);

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

@ -427,22 +427,27 @@ void RUBY::create_command(char *cname, char *iname, int argc) {
}
/* ---------------------------------------------------------------------
* RUBY::create_function(char *name, char *iname, SwigType *d, ParmList *l)
* RUBY::function()
*
* Create a function declaration and register it with the interpreter.
* name = Name of real C function
* iname = Name of function in scripting language
* t = Return datatype
* l = Function parameters
* --------------------------------------------------------------------- */
void RUBY::create_function(char *name, char *iname, SwigType *t, ParmList *l) {
void RUBY::function(DOH *node) {
char *name, *iname;
SwigType *t;
ParmList *l;
char source[256], target[256];
char *tm;
String *cleanup, *outarg;
Wrapper *f;
int i;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
l = Getattr(node,"parms");
/* Ruby needs no destructor wrapper */
if (current == DESTRUCTOR) {
Wrapper *dummy = NewWrapper();
@ -687,20 +692,24 @@ void RUBY::create_function(char *name, char *iname, SwigType *t, ParmList *l) {
}
/* ---------------------------------------------------------------------
* RUBY::link_variable(char *name, char *iname, SwigType *t)
* RUBY::variable()
*
* Create a link to a C variable.
* name = Name of C variable
* iname = Name of variable in scripting language
* t = Datatype of the variable
* --------------------------------------------------------------------- */
void RUBY::link_variable(char *name, char *iname, SwigType *t) {
void RUBY::variable(DOH *node) {
char *name, *iname;
SwigType *t;
char *tm, *source;
String *getfname, *setfname;
Wrapper *getf, *setf;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
getf = NewWrapper();
setf = NewWrapper();
@ -848,17 +857,21 @@ char *RUBY::validate_const_name(char *name) {
}
/* ---------------------------------------------------------------------
* RUBY::declare_const(char *name, char *iname, SwigType *type, char *value)
* RUBY::constant()
*
* Makes a constant.
* name = Name of the constant
* iname = Scripting language name of constant
* type = Datatype of the constant
* value = Constant value (as a string)
* --------------------------------------------------------------------- */
void RUBY::declare_const(char *name, char *iname, SwigType *type, char *value) {
void RUBY::constant(DOH *node) {
char *tm;
char *name, *iname;
SwigType *type;
char *value;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
type = Getattr(node,"type");
value = GetChar(node,"value");
if (current == CLASS_CONST)
iname = klass->strip(iname);

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

@ -21,9 +21,9 @@ class RUBY : public Language {
/* Virtual functions required by the SWIG parser */
virtual void parse_args(int, char *argv[]);
virtual void parse();
virtual void create_function(char *, char *, SwigType *, ParmList *);
virtual void link_variable(char *, char *, SwigType *);
virtual void declare_const(char *, char *, SwigType *, char *);
virtual void function(DOH *node);
virtual void variable(DOH *node);
virtual void constant(DOH *node);
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);

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

@ -264,7 +264,10 @@ TCL8::create_command(char *cname, char *iname) {
* ----------------------------------------------------------------------------- */
void
TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
TCL8::function(DOH *node) {
char *name, *iname;
SwigType *d;
ParmList *l;
Parm *p;
int pcount,i,j;
char *tm;
@ -272,6 +275,11 @@ TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
String *incode, *cleanup, *outarg, *argstr, *args;
int numopt= 0;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
d = Getattr(node,"type");
l = Getattr(node,"parms");
incode = NewString("");
cleanup = NewString("");
outarg = NewString("");
@ -530,14 +538,16 @@ TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
}
/* -----------------------------------------------------------------------------
* TCL8::link_variable()
* TCL8::variable()
* ----------------------------------------------------------------------------- */
static Hash *setf = 0;
static Hash *getf = 0;
void
TCL8::link_variable(char *name, char *iname, SwigType *t) {
TCL8::variable(DOH *node) {
char *name, *iname;
SwigType *t;
String *setname;
String *getname;
@ -547,6 +557,10 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
int setable = 1;
int tc;
name = GetChar(node,"name");
iname = GetChar(node,"scriptname");
t = Getattr(node,"type");
if (!setf) setf = NewHash();
if (!getf) getf = NewHash();
@ -755,17 +769,26 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
}
/* -----------------------------------------------------------------------------
* TCL8::declare_const()
* TCL8::constant()
* ----------------------------------------------------------------------------- */
void
TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
TCL8::constant(DOH *node) {
char *name;
SwigType *type;
char *value;
int OldStatus = Status;
SwigType *t;
char var_name[256];
char *tm;
String *rvalue;
Status = STAT_READONLY;
DOH *nnode;
name = GetChar(node,"name");
type = Getattr(node,"type");
value = GetChar(node,"value");
nnode = Copy(node);
/* Make a static variable */
sprintf(var_name,"_wrap_const_%s",name);
@ -784,7 +807,8 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
switch(SwigType_type(type)) {
case T_BOOL: case T_INT: case T_DOUBLE:
Printf(f_header,"static %s %s = %s;\n", SwigType_str(type,0), var_name, value);
link_variable(var_name,name,type);
Setattr(nnode,"name",var_name);
variable(nnode);
break;
case T_SHORT:
@ -801,7 +825,9 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
sprintf(var_name,"%s_char",var_name);
t = NewString("char");
SwigType_add_pointer(t);
link_variable(var_name,name,t);
Setattr(nnode,"name",var_name);
Setattr(nnode,"type",t);
variable(nnode);
Delete(t);
break;
@ -820,25 +846,31 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
sprintf(var_name,"%s_char",var_name);
t = NewSwigType(T_CHAR);
SwigType_add_pointer(t);
link_variable(var_name,name,t);
Setattr(nnode,"name",var_name);
Setattr(nnode,"type",t);
variable(nnode);
Delete(t);
break;
case T_FLOAT:
Printf(f_header,"static %s %s = (%s) (%s);\n", SwigType_lstr(type,0), var_name, SwigType_lstr(type,0), value);
link_variable(var_name,name,type);
Setattr(nnode,"name",var_name);
variable(nnode);
break;
case T_CHAR:
SwigType_add_pointer(type);
Printf(f_header,"static %s %s = \"%s\";\n", SwigType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
Setattr(nnode,"name",var_name);
Setattr(nnode,"type",type);
variable(nnode);
SwigType_del_pointer(type);
break;
case T_STRING:
Printf(f_header,"static %s %s = \"%s\";\n", SwigType_lstr(type,0), var_name, value);
link_variable(var_name,name,type);
Setattr(nnode,"name",var_name);
variable(nnode);
break;
case T_POINTER: case T_ARRAY: case T_REFERENCE:
@ -855,7 +887,9 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
Printf(f_init,"\t SWIG_MakePtr(%s_char, (void *) %s, SWIGTYPE%s);\n",
var_name, var_name, SwigType_manglestr(type));
sprintf(var_name,"%s_char",var_name);
link_variable(var_name,name,t);
Setattr(nnode,"type",t);
Setattr(nnode,"name",var_name);
variable(nnode);
Delete(t);
break;
@ -865,6 +899,7 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
}
}
Delete(rvalue);
Delete(nnode);
Status = OldStatus;
}

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

@ -27,9 +27,9 @@ private:
public :
virtual void parse_args(int, char *argv[]);
virtual void parse();
virtual void create_function(char *, char *, SwigType *, ParmList *);
virtual void link_variable(char *, char *, SwigType *);
virtual void declare_const(char *, char *, SwigType *, char *);
virtual void function(DOH *node);
virtual void variable(DOH *node);
virtual void constant(DOH *node);
virtual void initialize(void);
virtual void close(void);
virtual void set_module(char *);

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

@ -1561,7 +1561,7 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
/* Nah. Just produce a string that does the work for us */
emit_set_action(Swig_cmethod_call(mname, Wrapper_Getparms(w)));
}
lang->create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
DelWrapper(w);
} else {
lang->create_command(prev_wrap, iname);
@ -1660,15 +1660,15 @@ void cplus_emit_static_func(char *classname, char *, char *classrename,
if (!prev_wrap) {
if (!mode) {
// Not an added method and not objective C, just wrap it
lang->create_function(cname,iname, type, l);
new_create_function(cname,iname, type, l);
} else {
if (!ccode) {
strcpy(cname, Char(Swig_name_member(classname,mname)));
lang->create_function(cname,iname, type, l);
new_create_function(cname,iname, type, l);
} else {
Wrapper *w = Swig_cfunction_wrapper(cname, type, l, ccode);
Wrapper_print(w,f_wrappers);
lang->create_function(cname,iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(cname,iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
DelWrapper(w);
}
}
@ -1735,15 +1735,15 @@ void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
}
if (mode && ccode) {
Wrapper_print(w,f_wrappers);
lang->create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
} else if (mode) {
lang->create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
} else {
if (CPlusPlus)
emit_set_action(Swig_cppdestructor_call());
else
emit_set_action(Swig_cdestructor_call());
lang->create_function(cname, iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(cname, iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
}
DelWrapper(w);
}
@ -1803,7 +1803,7 @@ void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
Wrapper_print(w,f_wrappers);
}
}
lang->create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
DelWrapper(w);
}
@ -1893,7 +1893,7 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename
} else if (!mode) {
emit_set_action(Swig_cmemberget_call(mname, type));
}
lang->create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
} else {
// Already wrapped this function. Just patch it up
lang->create_command(prev_wrap,iname);
@ -2002,7 +2002,7 @@ void cplus_emit_variable_set(char *classname, char *classtype, char *classrename
emit_set_action(tm);
Delete(target);
}
lang->create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
} else {
lang->create_command(prev_wrap,iname);
}

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

@ -19,6 +19,23 @@ extern "C" {
static char cvsroot[] = "$Header$";
/* -----------------------------------------------------------------------------
* new_create_function()
*
* Create a new function
* ----------------------------------------------------------------------------- */
void new_create_function(char *name, char *iname, SwigType *type, ParmList *l) {
Hash *h;
h = NewHash();
Setattr(h,"name",name);
Setattr(h,"scriptname",iname);
Setattr(h,"type",type);
Setattr(h,"parms",l);
lang->function(h);
Delete(h);
}
/* -----------------------------------------------------------------------------
* emit_args()
*
@ -169,7 +186,7 @@ void emit_set_get(char *name, char *iname, SwigType *t) {
Wrapper_print(w,f_header);
new_iname = Swig_name_set(iname);
DohIncref(new_iname);
lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
Delete(new_iname);
DelWrapper(w);
}
@ -178,7 +195,7 @@ void emit_set_get(char *name, char *iname, SwigType *t) {
Wrapper_print(w,f_header);
new_iname = Swig_name_get(iname);
DohIncref(new_iname);
lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
new_create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
Delete(new_iname);
DelWrapper(w);
}

22
Source/SWIG1.1/internal.h
View file

@ -39,4 +39,26 @@ struct TMParm {
#define NI_NAMES 512
// Some functions for emitting some C++ helper code
extern void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
char *mname, char *mrename, SwigType *type, ParmList *l,
int mode);
extern void cplus_emit_static_func(char *classname, char *classtype, char *classrename,
char *mname, char *mrename, SwigType *type, ParmList *l,
int mode);
extern void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
char *name, char *iname, int mode);
extern void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
char *name, char *iname, ParmList *l, int mode);
extern void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
char *name, char *iname, SwigType *type, int mode);
extern void cplus_emit_variable_set(char *classname, char *classtype, char *classrename,
char *name, char *iname, SwigType *type, int mode);
extern char *cplus_base_class(char *name);

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

@ -337,8 +337,14 @@ void Language::cpp_declare_const(char *name, char *iname, SwigType *type, char *
} else {
new_value = value;
}
lang->declare_const(cname,cname,type, new_value);
Hash *n;
n = NewHash();
Setattr(n,"name",cname);
Setattr(n,"scriptname",cname);
Setattr(n,"type",type);
Setattr(n,"value",new_value);
lang->constant(n);
Delete(n);
if (!value) {
free(new_value);
@ -384,7 +390,12 @@ void Language::cpp_static_var(char *name, char *iname, SwigType *t) {
/* Link with this variable */
lang->link_variable(mname,cname,t);
Hash *n = NewHash();
Setattr(n,"name",mname);
Setattr(n,"scriptname", cname);
Setattr(n,"type",t);
lang->variable(n);
Delete(n);
}
/* -----------------------------------------------------------------------------

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

@ -274,6 +274,7 @@ static char *make_name(char *name) {
// ----------------------------------------------------------------------
void create_function(int ext, char *name, SwigType *t, ParmList *l) {
DOH *n;
if (Active_static) return; // Static declaration. Ignore
init_language();
@ -296,8 +297,13 @@ void create_function(int ext, char *name, SwigType *t, ParmList *l) {
emit_extern_func(name, t, l, 1, f_header);
}
// If this function has been declared inline, produce a function
lang->create_function(name, iname, t, l);
n = NewHash();
Setattr(n,"name", name);
Setattr(n,"scriptname", iname);
Setattr(n,"type", t);
Setattr(n,"parms", l);
lang->function(n);
Delete(n);
}
scanner_clear_start();
}
@ -328,7 +334,13 @@ void create_variable(int ext, char *name, SwigType *t) {
}
// Now dump it out
lang->link_variable(name, iname, t);
Hash *n;
n = NewHash();
Setattr(n,"name",name);
Setattr(n,"scriptname", iname);
Setattr(n,"type",t);
lang->variable(n);
Delete(n);
}
scanner_clear_start();
}
@ -362,7 +374,14 @@ void create_constant(char *name, SwigType *type, char *value) {
} else {
if (!WrapExtern) { // Only wrap the constant if not in %extern mode
String *tval = NewStringf("%(escape)s",value);
lang->declare_const(name, name, type, Char(tval));
Hash *n;
n = NewHash();
Setattr(n,"name",name);
Setattr(n,"scriptname",name);
Setattr(n,"type",type);
Setattr(n,"value",tval);
lang->constant(n);
Delete(n);
Delete(tval);
}
}

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

@ -87,93 +87,15 @@ struct Pragma {
Pragma *next;
};
/************************************************************************
* class language:
*
* This class defines the functions that need to be supported by the
* scripting language being used. The translator calls these virtual
* functions to output different types of code for different languages.
*
* By implementing this using virtual functions, hopefully it will be
* easy to support different types of scripting languages.
*
* The following functions are used :
*
* parse_args(argc, argv)
* Parse the arguments used by this language.
*
* parse()
* Entry function that starts parsing of a particular language
*
* create_function(fname, iname, rtype, parmlist)
* Creates a function wrappper.
*
* link_variable(vname, iname, type)
* Creates a link to a variable.
*
* declare_const(cname, type, value)
* Creates a constant (for #define).
*
* initialize(char *fn)
* Produces initialization code.
*
* headers()
* Produce code for headers
*
* close()
* Close up files
*
* usage_var(iname,type,string)
* Produces usage string for variable declaration.
*
* usage_func(iname,rttype, parmlist, string)
* Produces usage string for function declaration.
*
* usage_const(iname, type, value, string)
* Produces usage string for constants
*
* set_module(char *modname)
* Sets the name of the module (%module directive)
*
* add_native(char *name, char *funcname);
* Adds a native wrapper function to the initialize process
*
* --- C++ Functions ---
*
* These functions are optional additions to any of the target
* languages. SWIG handles inheritance, symbol tables, and other
* information.
*
* cpp_open_class(char *classname, char *rname)
* Open a new C++ class definition.
* cpp_close_class(char *)
* Close current C++ class
* cpp_member_func(char *name, char *rname, SwigType *rt, ParmList *l)
* Create a C++ member function
* cpp_constructor(char *name, char *iname, ParmList *l)
* Create a C++ constructor.
* cpp_destructor(char *name, char *iname)
* Create a C++ destructor
* cpp_variable(char *name, char *iname, SwigType *t)
* Create a C++ member data item.
* cpp_declare_const(char *name, char *iname, int type, char *value)
* Create a C++ constant.
* cpp_inherit(char *baseclass)
* Inherit data from baseclass.
* cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l)
* A C++ static member function.
* cpp_static_var(char *name, char *iname, SwigType *t)
* A C++ static member data variable.
*
*************************************************************************/
/* Real Language Class */
class Language {
public:
virtual void parse_args(int argc, char *argv[]) = 0;
virtual void parse() = 0;
virtual void create_function(char *, char *, SwigType *, ParmList *) = 0;
virtual void link_variable(char *, char *, SwigType *) = 0;
virtual void declare_const(char *, char *, SwigType *, char *) = 0;
virtual void function(DOH *node) = 0;
virtual void variable(DOH *node) = 0;
virtual void constant(DOH *node) = 0;
virtual void initialize(void) = 0;
virtual void close(void) = 0;
virtual void set_module(char *mod_name) = 0;
@ -215,36 +137,13 @@ 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_action(DOHString_or_char *decl);
extern int SWIG_main(int, char **, Language *);
// Some functions for emitting some C++ helper code
extern void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
char *mname, char *mrename, SwigType *type, ParmList *l,
int mode);
extern void cplus_emit_static_func(char *classname, char *classtype, char *classrename,
char *mname, char *mrename, SwigType *type, ParmList *l,
int mode);
extern void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
char *name, char *iname, int mode);
extern void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
char *name, char *iname, ParmList *l, int mode);
extern void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
char *name, char *iname, SwigType *type, int mode);
extern void cplus_emit_variable_set(char *classname, char *classtype, char *classrename,
char *name, char *iname, SwigType *type, int mode);
extern char *cplus_base_class(char *name);
/* These are in the new core */
extern "C" {

1
Source/Swig/swig.h
View file

@ -415,6 +415,7 @@ extern void Swig_except_clear();
#define Getvalue(x) Getattr(x,"value")
#define Getlname(x) Getattr(x,"lname")
#define Getignore(x) GetInt(x,"ignore")
#define Getparms(x) Getattr(x,"parms")
#define Settype(x,v) Setattr(x,"type",x)
#define Setname(x,v) Setattr(x,"name",v)