Ruby module replaced DataType with SwigType
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@684 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Masaki Fukushima
parent
b05126e3dc
commit
a68bf13ae4
4 changed files with 235 additions and 269 deletions
|
|
@ -13,8 +13,8 @@ AR = @AR@
|
|||
RANLIB = @RANLIB@
|
||||
|
||||
TARGET = libmodules11.a
|
||||
OBJS = swigmain.o tcl8.o python.o perl5.o #guile.o java.o mzscheme.o ruby.o
|
||||
SRCS = swigmain.cxx tcl8.cxx python.cxx perl5.cxx #guile.cxx java.cxx mzscheme.cxx ruby.cxx
|
||||
OBJS = swigmain.o tcl8.o python.o perl5.o ruby.o #guile.o java.o mzscheme.o
|
||||
SRCS = swigmain.cxx tcl8.cxx python.cxx perl5.cxx ruby.cxx #guile.cxx java.cxx mzscheme.cxx
|
||||
INCLUDE = -I$(srcdir)/../Include \
|
||||
-I$(srcdir)/../SWIG1.1 \
|
||||
-I$(srcdir)/../DOH/Include \
|
||||
|
|
|
|||
|
|
@ -18,8 +18,80 @@ static char cvsroot[] = "$Header$";
|
|||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
/* for debug */
|
||||
#define P(obj) printf("\"%s\"\n", Char(Str(obj)))
|
||||
|
||||
class RClass {
|
||||
private:
|
||||
String *temp;
|
||||
public:
|
||||
String *name; // class name (renamed)
|
||||
String *cname; // original C class/struct name
|
||||
String *vname; // variable name
|
||||
String *type;
|
||||
String *prefix;
|
||||
String *header;
|
||||
String *init;
|
||||
|
||||
String *aliases;
|
||||
String *includes;
|
||||
Hash *freemethods;
|
||||
Hash *predmethods;
|
||||
int destructor_defined;
|
||||
|
||||
RClass(void) {
|
||||
freemethods = NewHash();
|
||||
predmethods = NewHash();
|
||||
destructor_defined = 0;
|
||||
name = NewString("");
|
||||
cname = NewString("");
|
||||
vname = NewString("");
|
||||
type = NewString("");
|
||||
prefix = NewString("");
|
||||
header = NewString("");
|
||||
init = NewString("");
|
||||
aliases = NewString("");
|
||||
includes = NewString("");
|
||||
temp = NewString("");
|
||||
}
|
||||
~RClass() {
|
||||
Delete(name);
|
||||
Delete(cname);
|
||||
Delete(vname);
|
||||
Delete(type);
|
||||
Delete(prefix);
|
||||
Delete(header);
|
||||
Delete(init);
|
||||
Delete(aliases);
|
||||
Delete(includes);
|
||||
Delete(freemethods);
|
||||
Delete(predmethods);
|
||||
Delete(temp);
|
||||
}
|
||||
|
||||
void set_name(char *cn, char *rn, char *valn) {
|
||||
Clear(cname);
|
||||
Append(cname,cn);
|
||||
Clear(name);
|
||||
Append(name,valn);
|
||||
Clear(vname);
|
||||
Printf(vname,"c%s",name);
|
||||
Printv(prefix,(rn ? rn : cn), "_", 0);
|
||||
}
|
||||
|
||||
char *strip(char *s) {
|
||||
if (strncmp(s, Char(prefix), Len(prefix)) != 0)
|
||||
return s;
|
||||
Clear(temp);
|
||||
Append(temp,s);
|
||||
Replace(temp,prefix,"",DOH_REPLACE_ANY);
|
||||
return Char(temp);
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
static char *usage = (char*)"\
|
||||
Ruby Options\n\
|
||||
Ruby Options (available with -ruby)\n\
|
||||
-module name - Set module name\n\
|
||||
-toplevel - Do not define module\n\
|
||||
-feature name - Set feature name (used by `require')\n";
|
||||
|
|
@ -28,8 +100,8 @@ static char *module;
|
|||
static char *modvar;
|
||||
static char *feature;
|
||||
static int toplevel;
|
||||
static DOH *other_extern = 0;
|
||||
static DOH *other_init = 0;
|
||||
static String *other_extern = 0;
|
||||
static String *other_init = 0;
|
||||
static char *import_file;
|
||||
|
||||
static int current;
|
||||
|
|
@ -45,72 +117,14 @@ enum {
|
|||
STATIC_VAR
|
||||
};
|
||||
|
||||
static DOHHash *classes; // key=cname val=RClass
|
||||
static RClass *klass; // Currently processing class
|
||||
static DOHHash *special_methods; // Python style special method name table
|
||||
static Hash *classes; // key=cname val=RClass
|
||||
static RClass *klass; // Currently processing class
|
||||
static Hash *special_methods; // Python style special method name table
|
||||
|
||||
|
||||
#define RCLASS(hash, name) (RClass*)(Getattr(hash, name) ? Data(Getattr(hash, name)) : 0)
|
||||
#define SET_RCLASS(hash, name, klass) Setattr(hash, name, NewVoid(klass, 0))
|
||||
|
||||
static void indent(DOHString *s, char *sp = (char*)tab4) {
|
||||
char rep[256] = "\n";
|
||||
Insert(s,0,sp);
|
||||
strcpy(rep+1,sp);
|
||||
Replace(s,"\n", rep, DOH_REPLACE_ANY);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::RUBY()
|
||||
//
|
||||
// Constructor
|
||||
// ---------------------------------------------------------------------
|
||||
RUBY::RUBY(void) {
|
||||
module = 0;
|
||||
modvar = 0;
|
||||
feature = 0;
|
||||
toplevel = 0;
|
||||
import_file = 0;
|
||||
current = NO_CPP;
|
||||
klass = 0;
|
||||
classes = NewHash();
|
||||
special_methods = NewHash();
|
||||
|
||||
// Python style special method name.
|
||||
// Basic
|
||||
Setattr(special_methods, "__repr__", "inspect");
|
||||
Setattr(special_methods, "__str__", "to_s");
|
||||
Setattr(special_methods, "__cmp__", "<=>");
|
||||
Setattr(special_methods, "__hash__", "hash");
|
||||
Setattr(special_methods, "__nonzero__", "nonzero?");
|
||||
// Callable
|
||||
Setattr(special_methods, "__call__", "call");
|
||||
// Collection
|
||||
Setattr(special_methods, "__len__", "length");
|
||||
Setattr(special_methods, "__getitem__", "[]");
|
||||
Setattr(special_methods, "__setitem__", "[]=");
|
||||
// Numeric
|
||||
Setattr(special_methods, "__add__", "+");
|
||||
Setattr(special_methods, "__sub__", "-");
|
||||
Setattr(special_methods, "__mul__", "*");
|
||||
Setattr(special_methods, "__div__", "/");
|
||||
Setattr(special_methods, "__mod__", "%");
|
||||
Setattr(special_methods, "__divmod__", "divmod");
|
||||
Setattr(special_methods, "__pow__", "**");
|
||||
Setattr(special_methods, "__lshift__", "<<");
|
||||
Setattr(special_methods, "__rshift__", ">>");
|
||||
Setattr(special_methods, "__and__", "&");
|
||||
Setattr(special_methods, "__xor__", "^");
|
||||
Setattr(special_methods, "__or__", "|");
|
||||
Setattr(special_methods, "__neg__", "-@");
|
||||
Setattr(special_methods, "__pos__", "+@");
|
||||
Setattr(special_methods, "__abs__", "abs");
|
||||
Setattr(special_methods, "__invert__", "~");
|
||||
Setattr(special_methods, "__int__", "to_i");
|
||||
Setattr(special_methods, "__float__", "to_f");
|
||||
Setattr(special_methods, "__coerce__", "coerce");
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::parse_args(int argc, char *argv[])
|
||||
//
|
||||
|
|
@ -122,7 +136,7 @@ void RUBY::parse_args(int argc, char *argv[]) {
|
|||
if (argv[i]) {
|
||||
if (strcmp(argv[i],"-module") == 0) {
|
||||
if (argv[i+1]) {
|
||||
set_module(argv[i+1],0);
|
||||
set_module(argv[i+1]);
|
||||
Swig_mark_arg(i);
|
||||
Swig_mark_arg(i+1);
|
||||
i++;
|
||||
|
|
@ -168,6 +182,50 @@ void RUBY::parse_args(int argc, char *argv[]) {
|
|||
// Start parsing an interface file.
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::parse() {
|
||||
module = 0;
|
||||
modvar = 0;
|
||||
feature = 0;
|
||||
toplevel = 0;
|
||||
import_file = 0;
|
||||
current = NO_CPP;
|
||||
klass = 0;
|
||||
classes = NewHash();
|
||||
special_methods = NewHash();
|
||||
|
||||
// Python style special method name.
|
||||
// Basic
|
||||
Setattr(special_methods, "__repr__", "inspect");
|
||||
Setattr(special_methods, "__str__", "to_s");
|
||||
Setattr(special_methods, "__cmp__", "<=>");
|
||||
Setattr(special_methods, "__hash__", "hash");
|
||||
Setattr(special_methods, "__nonzero__", "nonzero?");
|
||||
// Callable
|
||||
Setattr(special_methods, "__call__", "call");
|
||||
// Collection
|
||||
Setattr(special_methods, "__len__", "length");
|
||||
Setattr(special_methods, "__getitem__", "[]");
|
||||
Setattr(special_methods, "__setitem__", "[]=");
|
||||
// Numeric
|
||||
Setattr(special_methods, "__add__", "+");
|
||||
Setattr(special_methods, "__sub__", "-");
|
||||
Setattr(special_methods, "__mul__", "*");
|
||||
Setattr(special_methods, "__div__", "/");
|
||||
Setattr(special_methods, "__mod__", "%");
|
||||
Setattr(special_methods, "__divmod__", "divmod");
|
||||
Setattr(special_methods, "__pow__", "**");
|
||||
Setattr(special_methods, "__lshift__", "<<");
|
||||
Setattr(special_methods, "__rshift__", ">>");
|
||||
Setattr(special_methods, "__and__", "&");
|
||||
Setattr(special_methods, "__xor__", "^");
|
||||
Setattr(special_methods, "__or__", "|");
|
||||
Setattr(special_methods, "__neg__", "-@");
|
||||
Setattr(special_methods, "__pos__", "+@");
|
||||
Setattr(special_methods, "__abs__", "abs");
|
||||
Setattr(special_methods, "__invert__", "~");
|
||||
Setattr(special_methods, "__int__", "to_i");
|
||||
Setattr(special_methods, "__float__", "to_f");
|
||||
Setattr(special_methods, "__coerce__", "coerce");
|
||||
|
||||
printf("Generating wrappers for Ruby\n");
|
||||
|
||||
other_extern = NewString("");
|
||||
|
|
@ -176,26 +234,23 @@ void RUBY::parse() {
|
|||
headers();
|
||||
|
||||
// typedef void *VALUE
|
||||
DataType *value = NewDataType(T_VOID);
|
||||
DataType_Setname(value,"void");
|
||||
DataType_add_pointer(value);
|
||||
DataType_typedef_add(value,(char*)"VALUE",0);
|
||||
SwigType *value = NewSwigType(T_VOID);
|
||||
SwigType_setbase(value,(char*)"void");
|
||||
SwigType_add_pointer(value);
|
||||
SwigType_typedef(value,(char*)"VALUE");
|
||||
|
||||
yyparse(); // Run the SWIG parser
|
||||
DelDataType(value);
|
||||
Delete(value);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::set_module(char *mod_name,char **mod_list)
|
||||
// RUBY::set_module(char *mod_name)
|
||||
//
|
||||
// Sets the module name. Does nothing if it's already set (so it can
|
||||
// be overridden as a command line option).
|
||||
//
|
||||
// mod_list is a NULL-terminated list of additional modules. This
|
||||
// is really only useful when building static executables.
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
void RUBY::set_module(char *mod_name, char **mod_list) {
|
||||
void RUBY::set_module(char *mod_name) {
|
||||
if (import_file) {
|
||||
Printf(f_init, "%srb_f_require(Qnil, rb_str_new2(\"%s\"));\n", tab4, mod_name);
|
||||
free(import_file); // Note: was allocated from C
|
||||
|
|
@ -218,6 +273,7 @@ void RUBY::set_module(char *mod_name, char **mod_list) {
|
|||
modvar[0] = 'm';
|
||||
strcpy(modvar+1, module);
|
||||
|
||||
#ifdef OLD
|
||||
if (mod_list) {
|
||||
Printv(other_extern,
|
||||
"#ifdef __cplusplus\n",
|
||||
|
|
@ -234,10 +290,11 @@ void RUBY::set_module(char *mod_name, char **mod_list) {
|
|||
"#endif\n",
|
||||
0);
|
||||
}
|
||||
#endif /* OLD */
|
||||
}
|
||||
|
||||
|
||||
static void insert_file(char *filename, DOHFile *file) {
|
||||
static void insert_file(char *filename, File *file) {
|
||||
if (Swig_insert_file(filename, file) == -1) {
|
||||
Printf(stderr,
|
||||
"SWIG : Fatal error. "
|
||||
|
|
@ -273,7 +330,7 @@ void RUBY::headers(void) {
|
|||
void RUBY::initialize() {
|
||||
if (!module) {
|
||||
Printf(stderr,"SWIG : *** Warning. No module name specified.\n");
|
||||
set_module((char*)"swig", NULL); // Pick a default name
|
||||
set_module((char*)"swig"); // Pick a default name
|
||||
}
|
||||
|
||||
Printf(f_header,"#define SWIG_init Init_%s\n", feature);
|
||||
|
|
@ -307,7 +364,9 @@ void RUBY::initialize() {
|
|||
void RUBY::close(void) {
|
||||
// Finish off our init function
|
||||
Printf(f_init, "\n");
|
||||
#ifdef OLD
|
||||
emit_ptr_equivalence(f_wrappers,f_init);
|
||||
#endif
|
||||
Printf(f_init,"}\n");
|
||||
}
|
||||
|
||||
|
|
@ -317,10 +376,18 @@ void RUBY::close(void) {
|
|||
// Creates a name for a wrapper function
|
||||
// cname = Name of the C function
|
||||
// ---------------------------------------------------------------------
|
||||
char *RUBY::make_wrapper_name(char *cname) {
|
||||
String *RUBY::make_wrapper_name(char *cname) {
|
||||
return Swig_name_wrapper(cname);
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------------
|
||||
* RUBY::add_native()
|
||||
* -------------------------------------------------------------------------- */
|
||||
void
|
||||
RUBY::add_native(char *name, char *funcname, SwigType *, ParmList *) {
|
||||
Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, funcname);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::create_command(char *cname, char *iname)
|
||||
//
|
||||
|
|
@ -330,7 +397,7 @@ char *RUBY::make_wrapper_name(char *cname) {
|
|||
// argc = Number of arguments
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::create_command(char *cname, char *iname, int argc) {
|
||||
DOHString *wname = NewString(make_wrapper_name(cname));
|
||||
String *wname = make_wrapper_name(cname);
|
||||
if (CPlusPlus) {
|
||||
Insert(wname,0,"VALUEFUNC(");
|
||||
Append(wname,")");
|
||||
|
|
@ -341,8 +408,8 @@ void RUBY::create_command(char *cname, char *iname, int argc) {
|
|||
iname = GetChar(special_methods, iname);
|
||||
}
|
||||
|
||||
DOHString *s = NewString("");
|
||||
DOHString *temp = NewString("");
|
||||
String *s = NewString("");
|
||||
String *temp = NewString("");
|
||||
char argcs[32];
|
||||
sprintf(argcs,"%d",argc);
|
||||
|
||||
|
|
@ -384,7 +451,7 @@ void RUBY::create_command(char *cname, char *iname, int argc) {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::create_function(char *name, char *iname, DataType *d, ParmList *l)
|
||||
// RUBY::create_function(char *name, char *iname, SwigType *d, ParmList *l)
|
||||
//
|
||||
// Create a function declaration and register it with the interpreter.
|
||||
// name = Name of real C function
|
||||
|
|
@ -392,10 +459,10 @@ void RUBY::create_command(char *cname, char *iname, int argc) {
|
|||
// t = Return datatype
|
||||
// l = Function parameters
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
||||
void RUBY::create_function(char *name, char *iname, SwigType *t, ParmList *l) {
|
||||
char source[256], target[256];
|
||||
char *tm;
|
||||
DOHString *cleanup, *outarg;
|
||||
String *cleanup, *outarg;
|
||||
Wrapper *f;
|
||||
int i;
|
||||
|
||||
|
|
@ -403,7 +470,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
if (current == DESTRUCTOR)
|
||||
return;
|
||||
|
||||
char *wname = make_wrapper_name(name);
|
||||
String *wname = make_wrapper_name(name);
|
||||
char mname[256], inamebuf[256];
|
||||
int predicate = 0;
|
||||
|
||||
|
|
@ -482,22 +549,6 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
Wrapper_add_local(f,"vresult","VALUE vresult = Qnil");
|
||||
int pcount = emit_args(t,l,f);
|
||||
|
||||
#if 0
|
||||
// Dave's note: This won't work with strings gone -- 7/9/00 */
|
||||
String temp;
|
||||
temp << "/* " << name << " */" << br;
|
||||
temp << "/* nparms = " << l->nparms << " */" << br;
|
||||
temp << "/* numarg = " << numarg << " */" << br;
|
||||
temp << "/* numopt = " << numopt << " */" << br;
|
||||
temp << "/* numignore = " << numignore << " */" << br;
|
||||
temp << "/* numoptreal = " << numoptreal << " */" << br;
|
||||
temp << "/* pcount = " << pcount << " */" << br;
|
||||
temp << "/* rb_scan_args(argc, argv, \""
|
||||
<< (numarg-numoptreal) << numoptreal << "\") */" << br;
|
||||
temp << br;
|
||||
if (numignore != 0) Printf(stderr, temp);
|
||||
f->code << temp;
|
||||
#endif
|
||||
// Emit count to check the number of arguments
|
||||
if (vararg) {
|
||||
Printf(f->code," rb_scan_args(argc, argv, \"%d%d\"", (numarg-numoptreal), numoptreal);
|
||||
|
|
@ -517,8 +568,8 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
|
||||
p = l;
|
||||
for (i = 0; i < pcount ; i++, p = Getnext(p)) {
|
||||
DataType *pt = Gettype(p);
|
||||
char *pn = Getname(p);
|
||||
SwigType *pt = Gettype(p);
|
||||
String *pn = Getname(p);
|
||||
|
||||
// Produce string representation of source and target arguments
|
||||
int selfp = (use_self && i == 0);
|
||||
|
|
@ -527,7 +578,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
else
|
||||
sprintf(source,"varg%d",i);
|
||||
|
||||
sprintf(target,"%s", Getlname(p));
|
||||
sprintf(target,"%s", Char(Getlname(p)));
|
||||
|
||||
if (!Getignore(p)) {
|
||||
char *tab = (char*)tab4;
|
||||
|
|
@ -539,25 +590,23 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
// Get typemap for this argument
|
||||
tm = ruby_typemap_lookup((char*)"in",pt,pn,source,target,f);
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s,tab);
|
||||
String *s = NewString(tm);
|
||||
Printv(f->code, s, "\n", 0);
|
||||
Replace(f->code, "$arg", source, DOH_REPLACE_ANY);
|
||||
Delete(s);
|
||||
} else {
|
||||
Printf(stderr,"%s : Line %d. No typemapping for datatype %s\n",
|
||||
input_file,line_number, DataType_str(pt,0));
|
||||
input_file,line_number, SwigType_str(pt,0));
|
||||
}
|
||||
if (j >= (pcount-numopt))
|
||||
Printv(f->code, tab4, "} \n");
|
||||
Printv(f->code, tab4, "} \n", 0);
|
||||
j++;
|
||||
}
|
||||
|
||||
// Check to see if there was any sort of a constaint typemap
|
||||
tm = ruby_typemap_lookup((char*)"check",pt,pn,source,target);
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(f->code, s, "\n", 0);
|
||||
Replace(f->code, "$arg", source, DOH_REPLACE_ANY);
|
||||
Delete(s);
|
||||
|
|
@ -566,8 +615,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
// Check if there was any cleanup code (save it for later)
|
||||
tm = ruby_typemap_lookup((char*)"freearg",pt,pn,target,source);
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(cleanup,s,"\n",0);
|
||||
Replace(cleanup,"$arg",source, DOH_REPLACE_ANY);
|
||||
Delete(s);
|
||||
|
|
@ -575,8 +623,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
|
||||
tm = ruby_typemap_lookup((char*)"argout",pt,pn,target,(char*)"vresult");
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(outarg, s, "\n", 0);
|
||||
Replace(outarg, "$arg", source, DOH_REPLACE_ANY);
|
||||
Delete(s);
|
||||
|
|
@ -588,19 +635,18 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
|
||||
|
||||
// Return value if necessary
|
||||
if (DataType_type(t) != T_VOID) {
|
||||
if (SwigType_type(t) != T_VOID) {
|
||||
if (predicate) {
|
||||
Printv(f->code, tab4, "vresult = (result ? Qtrue : Qfalse);\n", 0);
|
||||
} else {
|
||||
tm = ruby_typemap_lookup((char*)"out",t,name,(char*)"result",(char*)"vresult");
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(f->code, s, "\n", 0);
|
||||
Delete(s);
|
||||
} else {
|
||||
Printf(stderr,"%s : Line %d. No return typemap for datatype %s\n",
|
||||
input_file,line_number,DataType_str(t,0));
|
||||
input_file,line_number,SwigType_str(t,0));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -615,8 +661,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
if (NewObject) {
|
||||
tm = ruby_typemap_lookup((char*)"newfree",t,name,(char*)"result",(char*)"");
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(f->code,s,"\n", 0);
|
||||
Delete(s);
|
||||
}
|
||||
|
|
@ -630,8 +675,7 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
// Special processing on return value.
|
||||
tm = ruby_typemap_lookup((char*)"ret",t,name,(char*)"result",(char*)"");
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(f->code,s,"\n", 0);
|
||||
}
|
||||
|
||||
|
|
@ -652,17 +696,17 @@ void RUBY::create_function(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::link_variable(char *name, char *iname, DataType *t)
|
||||
// RUBY::link_variable(char *name, char *iname, SwigType *t)
|
||||
//
|
||||
// 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, DataType *t) {
|
||||
void RUBY::link_variable(char *name, char *iname, SwigType *t) {
|
||||
char *tm;
|
||||
|
||||
DOHString *getfname, *setfname;
|
||||
String *getfname, *setfname;
|
||||
Wrapper *getf, *setf;
|
||||
int mod_attr = 0;
|
||||
|
||||
|
|
@ -684,20 +728,19 @@ void RUBY::link_variable(char *name, char *iname, DataType *t) {
|
|||
if (!tm)
|
||||
tm = ruby_typemap_lookup((char*)"out",t,name,name,(char*)"_val");
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(getf->code,s,"\n", 0);
|
||||
Delete(s);
|
||||
} else if (DataType_type(t) == T_USER) {
|
||||
} else if (SwigType_type(t) == T_USER) {
|
||||
// Hack this into a pointer
|
||||
DataType_add_pointer(t);
|
||||
DataType_remember(t);
|
||||
SwigType_add_pointer(t);
|
||||
SwigType_remember(t);
|
||||
Printv(getf->code, tab4, "_val = SWIG_NewPointerObj((void *)&", name,
|
||||
", \"", DataType_manglestr(t), "\");\n", 0);
|
||||
DataType_del_pointer(t);
|
||||
", \"", SwigType_manglestr(t), "\");\n", 0);
|
||||
SwigType_del_pointer(t);
|
||||
} else {
|
||||
Printf(stderr,"%s: Line %d. Unable to link with variable type %s\n",
|
||||
input_file,line_number,DataType_str(t,0));
|
||||
input_file,line_number,SwigType_str(t,0));
|
||||
}
|
||||
Printv(getf->code, tab4, "return _val;\n}\n", 0);
|
||||
Wrapper_print(getf,f_wrappers);
|
||||
|
|
@ -717,21 +760,20 @@ void RUBY::link_variable(char *name, char *iname, DataType *t) {
|
|||
if (!tm)
|
||||
tm = ruby_typemap_lookup((char*)"in",t,name,(char*)"_val",name);
|
||||
if (tm) {
|
||||
DOHString *s = NewString(tm);
|
||||
indent(s);
|
||||
String *s = NewString(tm);
|
||||
Printv(setf->code,s,"\n",0);
|
||||
Delete(s);
|
||||
} else if (DataType_type(t) == T_USER) {
|
||||
DataType_add_pointer(t);
|
||||
Wrapper_add_localv(setf,"temp",DataType_lstr(t,0), "temp",0);
|
||||
Printv(setf->code, tab4, "temp = (", DataType_lstr(t,0), ")",
|
||||
"SWIG_ConvertPtr(_val, \"", DataType_manglestr(t), "\");\n",
|
||||
} else if (SwigType_type(t) == T_USER) {
|
||||
SwigType_add_pointer(t);
|
||||
Wrapper_add_localv(setf,"temp",SwigType_lstr(t,0), "temp",0);
|
||||
Printv(setf->code, tab4, "temp = (", SwigType_lstr(t,0), ")",
|
||||
"SWIG_ConvertPtr(_val, \"", SwigType_manglestr(t), "\");\n",
|
||||
0);
|
||||
Printv(setf->code, tab4, name, " = *temp;\n",0);
|
||||
DataType_del_pointer(t);
|
||||
SwigType_del_pointer(t);
|
||||
} else {
|
||||
Printf(stderr,"%s: Line %d. Unable to link with variable type %s\n",
|
||||
input_file,line_number,DataType_str(t,0));
|
||||
input_file,line_number,SwigType_str(t,0));
|
||||
}
|
||||
if (mod_attr)
|
||||
Printv(setf->code, tab4, "return _val;\n",0);
|
||||
|
|
@ -747,7 +789,7 @@ void RUBY::link_variable(char *name, char *iname, DataType *t) {
|
|||
Append(setfname,")");
|
||||
}
|
||||
|
||||
DOHString *s = NewString("");
|
||||
String *s = NewString("");
|
||||
switch (current) {
|
||||
case STATIC_VAR:
|
||||
// C++ class variable
|
||||
|
|
@ -820,7 +862,7 @@ char *RUBY::validate_const_name(char *name) {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::declare_const(char *name, char *iname, DataType *type, char *value)
|
||||
// RUBY::declare_const(char *name, char *iname, SwigType *type, char *value)
|
||||
//
|
||||
// Makes a constant.
|
||||
// name = Name of the constant
|
||||
|
|
@ -828,7 +870,7 @@ char *RUBY::validate_const_name(char *name) {
|
|||
// type = Datatype of the constant
|
||||
// value = Constant value (as a string)
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::declare_const(char *name, char *iname, DataType *type, char *value) {
|
||||
void RUBY::declare_const(char *name, char *iname, SwigType *type, char *value) {
|
||||
char *tm;
|
||||
|
||||
if (current == CLASS_CONST)
|
||||
|
|
@ -836,29 +878,27 @@ void RUBY::declare_const(char *name, char *iname, DataType *type, char *value) {
|
|||
|
||||
tm = ruby_typemap_lookup((char*)"const",type,name,value,iname);
|
||||
if (tm) {
|
||||
DOHString *str = NewString(tm);
|
||||
String *str = NewString(tm);
|
||||
Replace(str,"$value",value, DOH_REPLACE_ANY);
|
||||
if (current == CLASS_CONST) {
|
||||
Replace(str,"$module", klass->vname, DOH_REPLACE_ANY);
|
||||
indent(str);
|
||||
Printv(klass->init, str, "\n", 0);
|
||||
} else {
|
||||
if (toplevel)
|
||||
Replace(str,"$module", "rb_cObject", DOH_REPLACE_ANY);
|
||||
else
|
||||
Replace(str,"$module", modvar, DOH_REPLACE_ANY);
|
||||
indent(str);
|
||||
Printf(f_init,"%s\n", str);
|
||||
}
|
||||
Delete(str);
|
||||
} else {
|
||||
Printf(stderr,"%s : Line %d. Unable to create constant %s = %s\n",
|
||||
input_file, line_number, DataType_str(type,0), value);
|
||||
input_file, line_number, SwigType_str(type,0), value);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *source, char *target, WrapperFunction *f = 0)
|
||||
// RUBY::ruby_typemap_lookup(char *op, SwigType *type, char *pname, char *source, char *target, WrapperFunction *f = 0)
|
||||
//
|
||||
// Ruby specific typemap_lookup.
|
||||
// op = string code for type of mapping
|
||||
|
|
@ -868,46 +908,44 @@ void RUBY::declare_const(char *name, char *iname, DataType *type, char *value) {
|
|||
// target = a string containing the target value
|
||||
// f = a wrapper function object (optional)
|
||||
// ---------------------------------------------------------------------
|
||||
char *RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *source, char *target, Wrapper *f) {
|
||||
static DOHString *s = 0;
|
||||
char *RUBY::ruby_typemap_lookup(char *op, SwigType *type, String_or_char *pname, char *source, char *target, Wrapper *f) {
|
||||
static String *s = 0;
|
||||
char *tm;
|
||||
DOHString *target_replace = NewString(target);
|
||||
String *target_replace = NewString(target);
|
||||
target = Char(target_replace);
|
||||
|
||||
RClass *cls = RCLASS(classes, DataType_Getname(type));
|
||||
RClass *cls = RCLASS(classes, SwigType_base(type));
|
||||
|
||||
if (!s) s = NewString("");
|
||||
Clear(s);
|
||||
|
||||
if ((strcmp("out", op) == 0 || strcmp("in", op) == 0)
|
||||
&& strcmp(DataType_Getname(type), "VALUE") == 0) {
|
||||
&& Cmp(SwigType_base(type), "VALUE") == 0) {
|
||||
Printf(s,"$target = $source;");
|
||||
} else if (strcmp("out", op) == 0 && (DataType_Gettypecode(type) == T_USER) &&
|
||||
(DataType_is_pointer(type) == 1) && cls) {
|
||||
} else if (strcmp("out", op) == 0 && (SwigType_type(type) == T_POINTER) && cls) {
|
||||
const char *vname = (current == CONSTRUCTOR ? "self" : Char(cls->vname));
|
||||
Printv(s, "$target = Wrap_", cls->cname, "(", vname, ", $source);",0);
|
||||
} else if (strcmp("in", op)==0 && (DataType_Gettypecode(type) == T_USER) &&
|
||||
(DataType_is_pointer(type) == 1) && cls) {
|
||||
} else if (strcmp("in", op)==0 && (SwigType_type(type) == T_POINTER) && cls) {
|
||||
Printv(s, "Get_", cls->cname, "($source, $target);", 0);
|
||||
} else {
|
||||
tm = typemap_lookup(op, typemap_lang, type, pname, source, target, f);
|
||||
tm = Swig_typemap_lookup(op, type, pname, source, target, f);
|
||||
if (tm) {
|
||||
Delete(target_replace);
|
||||
return tm;
|
||||
}
|
||||
Clear(s);
|
||||
if (strcmp("in", op) == 0) {
|
||||
DOHString *v = NewString("");
|
||||
String *v = NewString("");
|
||||
if (from_VALUE(type, (char*)"$source", v))
|
||||
Printv(s, "$target = ", v, ";", 0);
|
||||
Delete(v);
|
||||
} else if (strcmp("out", op) == 0) {
|
||||
DOHString *v = NewString("");
|
||||
String *v = NewString("");
|
||||
if (to_VALUE(type, (char*)"$source", v))
|
||||
Printv(s, "$target = ", v, ";", 0);
|
||||
Delete(v);
|
||||
} else if (strcmp("const", op) == 0) {
|
||||
DOHString *v = NewString("");
|
||||
String *v = NewString("");
|
||||
if (to_VALUE(type, (char*)"$value", v, 1)) {
|
||||
Printv(s, "rb_define_const($module, \"$target\", ", v, ");", 0);
|
||||
validate_const_name(target);
|
||||
|
|
@ -923,12 +961,12 @@ char *RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *sou
|
|||
Replace(s,"$source",source, DOH_REPLACE_ANY);
|
||||
if (target && strlen(target) > 0)
|
||||
Replace(s,"$target",target, DOH_REPLACE_ANY);
|
||||
Replace(s,"$type", DataType_str(type,0), DOH_REPLACE_ANY);
|
||||
Replace(s,"$type", SwigType_str(type,0), DOH_REPLACE_ANY);
|
||||
return Char(s);
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::to_VALUE(DataType *type, char *value, literal)
|
||||
// RUBY::to_VALUE(SwigType *type, char *value, literal)
|
||||
//
|
||||
// Makes a VALUE (as a string)
|
||||
// type = Datatype of the C value
|
||||
|
|
@ -936,9 +974,9 @@ char *RUBY::ruby_typemap_lookup(char *op, DataType *type, char *pname, char *sou
|
|||
// str = resulting code (as a string)
|
||||
// raw = value is raw string (not quoted) ?
|
||||
// ---------------------------------------------------------------------
|
||||
int RUBY::to_VALUE(DataType *type, char *value, DOHString *str, int raw) {
|
||||
int RUBY::to_VALUE(SwigType *type, char *value, String *str, int raw) {
|
||||
Clear(str);
|
||||
switch(DataType_type(type)) {
|
||||
switch(SwigType_type(type)) {
|
||||
case T_INT:
|
||||
case T_SHORT:
|
||||
case T_LONG:
|
||||
|
|
@ -968,7 +1006,7 @@ int RUBY::to_VALUE(DataType *type, char *value, DOHString *str, int raw) {
|
|||
Printv(str, "rb_str_new2(", value, ")", 0);
|
||||
break;
|
||||
case T_POINTER: case T_ARRAY: case T_REFERENCE:
|
||||
Printv(str, "SWIG_NewPointerObj((void *)", value, ", \"", DataType_manglestr(type), "\")", 0);
|
||||
Printv(str, "SWIG_NewPointerObj((void *)", value, ", \"", SwigType_manglestr(type), "\")", 0);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -979,16 +1017,16 @@ int RUBY::to_VALUE(DataType *type, char *value, DOHString *str, int raw) {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// RUBY::from_VALUE(DataType *type, char *value)
|
||||
// RUBY::from_VALUE(SwigType *type, char *value)
|
||||
//
|
||||
// extract VALUE
|
||||
// type = Datatype of the C value
|
||||
// value = Ruby VALUE (as a string)
|
||||
// str = resulting code (as a string)
|
||||
// ---------------------------------------------------------------------
|
||||
int RUBY::from_VALUE(DataType *type, char *value, DOHString *str) {
|
||||
int RUBY::from_VALUE(SwigType *type, char *value, String *str) {
|
||||
Clear(str);
|
||||
switch(DataType_type(type)) {
|
||||
switch(SwigType_type(type)) {
|
||||
case T_INT:
|
||||
Printv(str, "NUM2INT(", value, ")", 0);
|
||||
break;
|
||||
|
|
@ -1021,7 +1059,7 @@ int RUBY::from_VALUE(DataType *type, char *value, DOHString *str) {
|
|||
Printv(str, "STR2CSTR(", value, ")", 0);
|
||||
break;
|
||||
case T_POINTER: case T_ARRAY: case T_REFERENCE:
|
||||
Printv(str, "SWIG_ConvertPtr(", value, ", \"", DataType_manglestr(type), "\")", 0);
|
||||
Printv(str, "(", SwigType_lstr(type,0), ")SWIG_ConvertPtr(", value, ", \"", SwigType_manglestr(type), "\")", 0);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
|
|
@ -1113,7 +1151,7 @@ void RUBY::cpp_close_class() {
|
|||
Replace(klass->aliases,"$class", klass->vname, DOH_REPLACE_ANY);
|
||||
Printv(klass->init, klass->aliases,0);
|
||||
|
||||
DOHString *s = NewString("");
|
||||
String *s = NewString("");
|
||||
Printv(s, tab4, "rb_undef_method(CLASS_OF(", klass->vname,
|
||||
"), \"new\");\n", 0);
|
||||
Replace(klass->init,"$constructor", s, DOH_REPLACE_ANY);
|
||||
|
|
@ -1147,7 +1185,7 @@ void RUBY::cpp_inherit(char **baseclass, int mode) {
|
|||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// void RUBY::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l)
|
||||
// void RUBY::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l)
|
||||
//
|
||||
// Method for adding C++ member function
|
||||
//
|
||||
|
|
@ -1168,7 +1206,7 @@ void RUBY::cpp_inherit(char **baseclass, int mode) {
|
|||
// classname.
|
||||
//
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) {
|
||||
void RUBY::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) {
|
||||
current = MEMBER_FUNC;
|
||||
this->Language::cpp_member_func(name, iname, t, l);
|
||||
current = NO_CPP;
|
||||
|
|
@ -1204,9 +1242,9 @@ void RUBY::cpp_destructor(char *name, char *newname) {
|
|||
current = DESTRUCTOR;
|
||||
this->Language::cpp_destructor(name, newname);
|
||||
|
||||
DOHString *freefunc = NewString("");
|
||||
DOHString *freeproto = NewString("");
|
||||
DOHString *freebody = NewString("");
|
||||
String *freefunc = NewString("");
|
||||
String *freeproto = NewString("");
|
||||
String *freebody = NewString("");
|
||||
|
||||
Printv(freefunc, "free_", klass->cname, 0);
|
||||
Printv(freeproto, "static void ", freefunc, "(", klass->type, " *);\n", 0);
|
||||
|
|
@ -1240,7 +1278,7 @@ void RUBY::cpp_destructor(char *name, char *newname) {
|
|||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// void RUBY::cpp_variable(char *name, char *iname, DataType *t)
|
||||
// void RUBY::cpp_variable(char *name, char *iname, SwigType *t)
|
||||
//
|
||||
// Wrap a C++ data member
|
||||
//
|
||||
|
|
@ -1251,14 +1289,14 @@ void RUBY::cpp_destructor(char *name, char *newname) {
|
|||
//
|
||||
// This creates a pair of functions to set/get the variable of a member.
|
||||
// --------------------------------------------------------------------
|
||||
void RUBY::cpp_variable(char *name, char *iname, DataType *t) {
|
||||
void RUBY::cpp_variable(char *name, char *iname, SwigType *t) {
|
||||
current = MEMBER_VAR;
|
||||
this->Language::cpp_variable(name, iname, t);
|
||||
current = NO_CPP;
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// void RUBY::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l)
|
||||
// void RUBY::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l)
|
||||
//
|
||||
// Wrap a static C++ function
|
||||
//
|
||||
|
|
@ -1268,14 +1306,14 @@ void RUBY::cpp_variable(char *name, char *iname, DataType *t) {
|
|||
// t = Return datatype
|
||||
// l = Parameters
|
||||
// ----------------------------------------------------------------------
|
||||
void RUBY::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
|
||||
void RUBY::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) {
|
||||
current = STATIC_FUNC;
|
||||
this->Language::cpp_static_func(name, iname, t, l);
|
||||
current = NO_CPP;
|
||||
}
|
||||
|
||||
// ----------------------------------------------------------------------
|
||||
// void RUBY::cpp_declare_const(char *name, char *iname, DataType *t, char *value)
|
||||
// void RUBY::cpp_declare_const(char *name, char *iname, SwigType *t, char *value)
|
||||
//
|
||||
// Create a C++ constant
|
||||
//
|
||||
|
|
@ -1287,14 +1325,14 @@ void RUBY::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) {
|
|||
//
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
void RUBY::cpp_declare_const(char *name, char *iname, DataType *type, char *value) {
|
||||
void RUBY::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) {
|
||||
current = CLASS_CONST;
|
||||
this->Language::cpp_declare_const(name, iname, type, value);
|
||||
current = NO_CPP;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// void RUBY::cpp_static_var(char *name, char *iname, DataType *t)
|
||||
// void RUBY::cpp_static_var(char *name, char *iname, SwigType *t)
|
||||
//
|
||||
// Wrap a static C++ variable
|
||||
//
|
||||
|
|
@ -1304,7 +1342,7 @@ void RUBY::cpp_declare_const(char *name, char *iname, DataType *type, char *valu
|
|||
// t = Datatype
|
||||
//
|
||||
// ---------------------------------------------------------------------
|
||||
void RUBY::cpp_static_var(char *name, char *iname, DataType *t) {
|
||||
void RUBY::cpp_static_var(char *name, char *iname, SwigType *t) {
|
||||
current = STATIC_VAR;
|
||||
this->Language::cpp_static_var(name, iname, t);
|
||||
current = NO_CPP;
|
||||
|
|
@ -1316,7 +1354,7 @@ void RUBY::cpp_static_var(char *name, char *iname, DataType *t) {
|
|||
// A forward class declaration
|
||||
// -----------------------------------------------------------------------
|
||||
void RUBY::cpp_class_decl(char *cname, char *rename, char *type) {
|
||||
DOHString *valid_name = NewString((rename ? rename : cname));
|
||||
String *valid_name = NewString((rename ? rename : cname));
|
||||
validate_const_name(Char(valid_name));
|
||||
klass->set_name(cname, rename, Char(valid_name));
|
||||
SET_RCLASS(classes, cname, klass);
|
||||
|
|
|
|||
|
|
@ -10,83 +10,14 @@
|
|||
*
|
||||
********************************************************************/
|
||||
|
||||
class RClass {
|
||||
private:
|
||||
DOHString *temp;
|
||||
public:
|
||||
DOHString *name; // class name (renamed)
|
||||
DOHString *cname; // original C class/struct name
|
||||
DOHString *vname; // variable name
|
||||
DOHString *type;
|
||||
DOHString *prefix;
|
||||
DOHString *header;
|
||||
DOHString *init;
|
||||
|
||||
DOHString *aliases;
|
||||
DOHString *includes;
|
||||
DOH *freemethods;
|
||||
DOH *predmethods;
|
||||
int destructor_defined;
|
||||
|
||||
RClass(void) {
|
||||
freemethods = NewHash();
|
||||
predmethods = NewHash();
|
||||
destructor_defined = 0;
|
||||
name = NewString("");
|
||||
cname = NewString("");
|
||||
vname = NewString("");
|
||||
type = NewString("");
|
||||
prefix = NewString("");
|
||||
header = NewString("");
|
||||
init = NewString("");
|
||||
aliases = NewString("");
|
||||
includes = NewString("");
|
||||
temp = NewString("");
|
||||
}
|
||||
~RClass() {
|
||||
Delete(name);
|
||||
Delete(cname);
|
||||
Delete(vname);
|
||||
Delete(type);
|
||||
Delete(prefix);
|
||||
Delete(header);
|
||||
Delete(init);
|
||||
Delete(aliases);
|
||||
Delete(includes);
|
||||
Delete(freemethods);
|
||||
Delete(predmethods);
|
||||
Delete(temp);
|
||||
}
|
||||
|
||||
void set_name(char *cn, char *rn, char *valn) {
|
||||
Clear(cname);
|
||||
Append(cname,cn);
|
||||
Clear(name);
|
||||
Append(name,valn);
|
||||
Clear(vname);
|
||||
Printf(vname,"c%s",name);
|
||||
Printv(prefix,(rn ? rn : cn), "_", 0);
|
||||
}
|
||||
|
||||
char *strip(char *s) {
|
||||
if (strncmp(s, Char(prefix), Len(prefix)) != 0)
|
||||
return s;
|
||||
Clear(temp);
|
||||
Append(temp,s);
|
||||
Replace(temp,prefix,"",DOH_REPLACE_ANY);
|
||||
return Char(temp);
|
||||
}
|
||||
};
|
||||
|
||||
class RUBY : public Language {
|
||||
private:
|
||||
virtual char *make_wrapper_name(char *cname);
|
||||
protected:
|
||||
virtual String *make_wrapper_name(char *cname);
|
||||
virtual char *validate_const_name(char *name);
|
||||
virtual char *ruby_typemap_lookup(char *, SwigType *, char *, char *, char *, Wrapper * = 0);
|
||||
virtual char *ruby_typemap_lookup(char *, SwigType *, String_or_char *, char *, char *, Wrapper * = 0);
|
||||
virtual int to_VALUE(SwigType *, char *, DOHString *, int = 0);
|
||||
virtual int from_VALUE(SwigType *, char *, DOHString *);
|
||||
public:
|
||||
RUBY();
|
||||
// Virtual functions required by the SWIG parser
|
||||
virtual void parse_args(int, char *argv[]);
|
||||
virtual void parse();
|
||||
|
|
@ -96,8 +27,10 @@ class RUBY : public Language {
|
|||
virtual void initialize(void);
|
||||
virtual void headers(void);
|
||||
virtual void close(void);
|
||||
virtual void set_module(char *,char **);
|
||||
virtual void set_module(char *);
|
||||
virtual void add_native(char *, char *, SwigType *, ParmList *);
|
||||
virtual void create_command(char *, char *, int);
|
||||
virtual void import(char *);
|
||||
|
||||
// C++ language extensions.
|
||||
virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l);
|
||||
|
|
@ -117,10 +50,6 @@ class RUBY : public Language {
|
|||
// Pragma directive
|
||||
virtual void pragma(char *, char *, char *);
|
||||
virtual void cpp_pragma(Pragma *);
|
||||
|
||||
// Import directive
|
||||
virtual void import(char *filename);
|
||||
|
||||
};
|
||||
|
||||
/*
|
||||
|
|
|
|||
|
|
@ -35,9 +35,8 @@ static char cvsroot[] = "$Header$";
|
|||
#include "java.h"
|
||||
#include "guile.h"
|
||||
#include "mzscheme.h"
|
||||
#include "ruby.h"
|
||||
|
||||
#endif
|
||||
#include "ruby.h"
|
||||
|
||||
#include <ctype.h>
|
||||
|
||||
|
|
@ -96,10 +95,10 @@ int main(int argc, char **argv) {
|
|||
} else if (strcmp(argv[i],"-mzscheme") == 0) {
|
||||
dl = new MZSCHEME;
|
||||
Swig_mark_arg(i);
|
||||
#endif
|
||||
} else if (strcmp(argv[i],"-ruby") == 0) {
|
||||
dl = new RUBY;
|
||||
Swig_mark_arg(i);
|
||||
#endif
|
||||
} else if (strcmp(argv[i],"-help") == 0) {
|
||||
fputs(usage,stderr);
|
||||
Swig_mark_arg(i);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue