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@925 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-10-18 05:06:39 +00:00
commit c34628aca5
19 changed files with 307 additions and 202 deletions
Download patch file Download diff file Expand all files Collapse all files

43
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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
SWIG/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 *);