diff --git a/Source/Modules1.1/Makefile.in b/Source/Modules1.1/Makefile.in index cce7f755a..2e9910d79 100644 --- a/Source/Modules1.1/Makefile.in +++ b/Source/Modules1.1/Makefile.in @@ -13,8 +13,8 @@ AR = @AR@ RANLIB = @RANLIB@ TARGET = libmodules11.a -OBJS = swigmain.o tcl8.o perl5.o python.o guile.o java.o mzscheme.o ruby.o -SRCS = swigmain.cxx tcl8.cxx perl5.cxx python.cxx guile.cxx java.cxx mzscheme.cxx ruby.cxx +OBJS = swigmain.o tcl8.o #perl5.o python.o guile.o java.o mzscheme.o ruby.o +SRCS = swigmain.cxx tcl8.cxx #perl5.cxx python.cxx guile.cxx java.cxx mzscheme.cxx ruby.cxx INCLUDE = -I$(srcdir)/../Include \ -I$(srcdir)/../SWIG1.1 \ -I$(srcdir)/../DOH/Include \ diff --git a/Source/Modules1.1/guile.h b/Source/Modules1.1/guile.h index d9c67faf9..e2e06e153 100644 --- a/Source/Modules1.1/guile.h +++ b/Source/Modules1.1/guile.h @@ -34,22 +34,22 @@ private: GUILE_LSTYLE_LTDLMOD, // "native" guile? GUILE_LSTYLE_HOBBIT // use (hobbit4d link) } linkage; - void get_pointer(char *iname, int parm, DataType *t, + void get_pointer(char *iname, int parm, SwigType *t, Wrapper *f, DOHString_or_char *proc_name, int num_scheme_parm); - void usage_var(char *, DataType *, DOHString *usage); - void usage_func(char *, DataType *, ParmList *, DOHString *usage); - void usage_returns(char *, DataType *, ParmList *, DOHString *usage); - void usage_const(char *, DataType *, char *, DOHString *usage); + void usage_var(char *, SwigType *, DOHString *usage); + void usage_func(char *, SwigType *, ParmList *, DOHString *usage); + void usage_returns(char *, SwigType *, ParmList *, DOHString *usage); + void usage_const(char *, SwigType *, char *, DOHString *usage); void emit_linkage(char *module_name); public : GUILE (); void parse_args (int, char *argv[]); void parse (); - void create_function (char *, char *, DataType *, ParmList *); - void link_variable (char *, char *, DataType *); - void declare_const (char *, char *, DataType *, char *); + void create_function (char *, char *, SwigType *, ParmList *); + void link_variable (char *, char *, SwigType *); + void declare_const (char *, char *, SwigType *, char *); void initialize (); void headers (void); void close (void); diff --git a/Source/Modules1.1/java.h b/Source/Modules1.1/java.h index 29af6d8b9..6c86b452e 100644 --- a/Source/Modules1.1/java.h +++ b/Source/Modules1.1/java.h @@ -11,10 +11,10 @@ public : void parse_args(int, char *argv[]); void parse(); - void add_native(char *, char *, DataType *, ParmList *); - void create_function(char *, char *, DataType *, ParmList *); - void link_variable(char *, char *, DataType *); - void declare_const(char *, char *, DataType *, char *); + void add_native(char *, char *, SwigType *, ParmList *); + void create_function(char *, char *, SwigType *, ParmList *); + void link_variable(char *, char *, SwigType *); + void declare_const(char *, char *, SwigType *, char *); void initialize(void); void headers(void); void close(void); @@ -22,28 +22,28 @@ public : void create_command(char *, char *); void pragma(char *lang, char *code, char *value); - void add_typedef(DataType *t, char *name); + void add_typedef(SwigType *t, char *name); void cpp_open_class(char *classname, char *rename, char *ctype, int strip); void cpp_close_class(); - void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); - void cpp_static_func(char *name, char *iname, DataType *t, ParmList *l); + void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); + void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l); void cpp_constructor(char *name, char *iname, ParmList *l); void cpp_destructor(char *name, char *newname); void cpp_class_decl(char *name, char *rename, char *type); void cpp_inherit(char **baseclass, int); - void cpp_variable(char *name, char *iname, DataType *t); - void cpp_static_var(char *, char *, class DataType *); - void cpp_declare_const(char *name, char *iname, DataType *type, char *value); + void cpp_variable(char *name, char *iname, SwigType *t); + void cpp_static_var(char *, char *, SwigType *); + void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); /* Java Module methods */ void emit_classdef(); void emit_shadow_classdef(); char *JNICALL(DOHString_or_char *func); - char *SwigTcToJniType(DataType *t, int ret); - char *SwigTcToJavaType(DataType *t, int ret, int inShadow); - char *SwigTcToJniScalarType(DataType *t); - char *JavaTypeFromTypemap(char *op, char *lang, DataType *t, char *pname); + char *SwigTcToJniType(SwigType *t, int ret); + char *SwigTcToJavaType(SwigType *t, int ret, int inShadow); + char *SwigTcToJniScalarType(SwigType *t); + char *JavaTypeFromTypemap(char *op, char *lang, SwigType *t, char *pname); char *makeValidJniName(char *name); - char *JavaMethodSignature(DataType *t, int ret, int inShadow); + char *JavaMethodSignature(SwigType *t, int ret, int inShadow); void writeRegisterNatives(); }; diff --git a/Source/Modules1.1/mzscheme.h b/Source/Modules1.1/mzscheme.h index 082cd6aa5..01b7f74fe 100644 --- a/Source/Modules1.1/mzscheme.h +++ b/Source/Modules1.1/mzscheme.h @@ -26,18 +26,18 @@ class MZSCHEME : public Language { private: - void get_pointer(DOHString_or_char *name, int parm, DataType *t, Wrapper *f); - void usage_var(char *, DataType *, DOHString *usage); - void usage_func(char *, DataType *, ParmList *, DOHString *usage); - void usage_returns(char *, DataType *, ParmList *, DOHString *usage); - void usage_const(char *, DataType *, char *, DOHString *usage); + void get_pointer(DOHString_or_char *name, int parm, SwigType *t, Wrapper *f); + void usage_var(char *, SwigType *, DOHString *usage); + void usage_func(char *, SwigType *, ParmList *, DOHString *usage); + void usage_returns(char *, SwigType *, ParmList *, DOHString *usage); + void usage_const(char *, SwigType *, char *, DOHString *usage); public : void parse_args (int, char *argv[]); void parse (); - void create_function (char *, char *, DataType *, ParmList *); - void link_variable (char *, char *, DataType *); - void declare_const (char *, char *, DataType *, char *); + void create_function (char *, char *, SwigType *, ParmList *); + void link_variable (char *, char *, SwigType *); + void declare_const (char *, char *, SwigType *, char *); void initialize (); void headers (void); void close (void); diff --git a/Source/Modules1.1/perl5.h b/Source/Modules1.1/perl5.h index 34a04676d..f28328081 100644 --- a/Source/Modules1.1/perl5.h +++ b/Source/Modules1.1/perl5.h @@ -22,38 +22,38 @@ class PERL5 : public Language { private: void get_pointer(char *iname, char *srcname, char *src, char *dest, - DataType *t, DOHString *f, char *ret); - char *usage_var(char *, DataType *); - char *usage_func(char *, DataType *, ParmList *); - char *usage_const(char *, DataType *, char *); + SwigType *t, DOHString *f, char *ret); + char *usage_var(char *, SwigType *); + char *usage_func(char *, SwigType *, ParmList *); + char *usage_const(char *, SwigType *, char *); public : virtual void parse_args(int, char *argv[]); virtual void parse(); - virtual void create_function(char *, char *, DataType *, ParmList *); - virtual void link_variable(char *, char *, DataType *); - virtual void declare_const(char *, char *, DataType *, char *); + 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 initialize(void); virtual void headers(void); virtual void close(void); virtual void set_module(char *, char **); virtual void set_init(char *); - virtual void add_native(char *, char *, DataType *, ParmList *); + virtual void add_native(char *, char *, SwigType *, ParmList *); virtual void create_command(char *, char *); // Support for blessed perl thingies.... virtual void cpp_open_class(char *classname, char *rename, char *ctype, int strip); virtual void cpp_close_class(); - virtual void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); - virtual void cpp_static_func(char *name, char *iname, DataType *t, ParmList *l); - virtual void cpp_variable(char *name, char *iname, DataType *t); + virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); + virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l); + virtual void cpp_variable(char *name, char *iname, SwigType *t); virtual void cpp_constructor(char *name, char *iname, ParmList *l); virtual void cpp_destructor(char *name, char *newname); virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); - virtual void cpp_declare_const(char *name, char *iname, DataType *type, char *value); + virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); virtual void cpp_class_decl(char *, char *, char *); - virtual void add_typedef(DataType *t, char *name); + virtual void add_typedef(SwigType *t, char *name); virtual void pragma(char *, char *, char *); virtual void import(char *filename); }; diff --git a/Source/Modules1.1/python.h b/Source/Modules1.1/python.h index 29b6e9660..bac870730 100644 --- a/Source/Modules1.1/python.h +++ b/Source/Modules1.1/python.h @@ -23,13 +23,13 @@ class PYTHON : public Language { protected: - void get_pointer(char *iname, char *srcname, char *src, char *dest, DataType *t, DOHString *f, char *ret); + void get_pointer(char *iname, char *srcname, char *src, char *dest, SwigType *t, DOHString *f, char *ret); void add_method(char *name, char *function, int kw); void print_methods(); - char *usage_var(char *, DataType *); - char *usage_func(char *, DataType *, ParmList *); - char *usage_const(char *, DataType *, char *); + char *usage_var(char *, SwigType *); + char *usage_func(char *, SwigType *, ParmList *); + char *usage_const(char *, SwigType *, char *); virtual void initialize_cmodule(); virtual void close_cmodule(); @@ -43,33 +43,33 @@ public : // Don't change any of this virtual void parse_args(int, char *argv[]); virtual void parse(); - virtual void create_function(char *, char *, DataType *, ParmList *); - virtual void link_variable(char *, char *, DataType *); - virtual void declare_const(char *, char *, DataType *, char *); + 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 initialize(void); virtual void headers(void); virtual void close(void); virtual void set_module(char *, char **); virtual void set_init(char *); - virtual void add_native(char *, char *, DataType *, ParmList *); + virtual void add_native(char *, char *, SwigType *, ParmList *); virtual void create_command(char *, char *); virtual void import(char *); // C++ extensions---for creating shadow classes - virtual void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); + virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); virtual void cpp_constructor(char *name, char *iname, ParmList *l); virtual void cpp_destructor(char *name, char *newname); virtual void cpp_open_class(char *classname, char *rname, char *ctype, int strip); virtual void cpp_close_class(); virtual void cpp_cleanup(); virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); - virtual void cpp_variable(char *name, char *iname, DataType *t); - virtual void cpp_declare_const(char *name, char *iname, DataType *type, char *value); + virtual void cpp_variable(char *name, char *iname, SwigType *t); + virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); virtual void cpp_class_decl(char *, char *,char *); virtual void pragma(char *, char *, char *); virtual void cpp_pragma(Pragma *); - virtual void add_typedef(DataType *t, char *name); + virtual void add_typedef(SwigType *t, char *name); }; #define PYSHADOW_MEMBER 0x2 diff --git a/Source/Modules1.1/ruby.h b/Source/Modules1.1/ruby.h index 1fea89a5b..f7b59c5d0 100644 --- a/Source/Modules1.1/ruby.h +++ b/Source/Modules1.1/ruby.h @@ -82,17 +82,17 @@ class RUBY : public Language { private: virtual char *make_wrapper_name(char *cname); virtual char *validate_const_name(char *name); - virtual char *ruby_typemap_lookup(char *, DataType *, char *, char *, char *, Wrapper * = 0); - virtual int to_VALUE(DataType *, char *, DOHString *, int = 0); - virtual int from_VALUE(DataType *, char *, DOHString *); + virtual char *ruby_typemap_lookup(char *, SwigType *, 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(); - virtual void create_function(char *, char *, DataType *, ParmList *); - virtual void link_variable(char *, char *, DataType *); - virtual void declare_const(char *, char *, DataType *, char *); + 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 initialize(void); virtual void headers(void); virtual void close(void); @@ -100,16 +100,16 @@ class RUBY : public Language { virtual void create_command(char *, char *, int); // C++ language extensions. - virtual void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); + virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); virtual void cpp_constructor(char *name, char *iname, ParmList *l); virtual void cpp_destructor(char *name, char *newname); virtual void cpp_open_class(char *classname, char *rname, char *ctype, int strip); virtual void cpp_close_class(); virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); - virtual void cpp_variable(char *name, char *iname, DataType *t); - virtual void cpp_static_func(char *name, char *iname, DataType *t, ParmList *l); - virtual void cpp_declare_const(char *name, char *iname, DataType *type, char *value); - virtual void cpp_static_var(char *name, char *iname, DataType *t); + virtual void cpp_variable(char *name, char *iname, SwigType *t); + virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l); + virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); + virtual void cpp_static_var(char *name, char *iname, SwigType *t); // Declaration of a class, but not a full definition virtual void cpp_class_decl(char *, char *, char *); diff --git a/Source/Modules1.1/swigmain.cxx b/Source/Modules1.1/swigmain.cxx index 271596824..95ca8fcfe 100644 --- a/Source/Modules1.1/swigmain.cxx +++ b/Source/Modules1.1/swigmain.cxx @@ -27,6 +27,8 @@ static char cvsroot[] = "$Header$"; #include "swigconfig.h" #include "mod11.h" #include "tcl8.h" + +#ifdef OLD #include "perl5.h" #include "java.h" #include "python.h" @@ -34,6 +36,8 @@ static char cvsroot[] = "$Header$"; #include "mzscheme.h" #include "ruby.h" +#endif + #include #ifndef SWIG_LANG @@ -74,6 +78,7 @@ int main(int argc, char **argv) { } else if (strcmp(argv[i],"-tcl8") == 0) { dl = new TCL8; Swig_mark_arg(i); +#ifdef OLD } else if (strcmp(argv[i],"-perl5") == 0) { dl = new PERL5; Swig_mark_arg(i); @@ -92,6 +97,7 @@ int main(int argc, char **argv) { } 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); diff --git a/Source/Modules1.1/tcl8.cxx b/Source/Modules1.1/tcl8.cxx index 8cce30907..5ebeac3fc 100644 --- a/Source/Modules1.1/tcl8.cxx +++ b/Source/Modules1.1/tcl8.cxx @@ -38,12 +38,12 @@ Tcl 8.0 Options (available with -tcl)\n\ static char *ns_name = 0; -static DOHString *mod_init = 0; -static DOHString *mod_extern = 0; -static DOHString *cmd_info = 0; -static DOHString *var_info = 0; -static DOHString *methods = 0; -static DOHString *attributes = 0; +static String *mod_init = 0; +static String *mod_extern = 0; +static String *cmd_info = 0; +static String *var_info = 0; +static String *methods = 0; +static String *attributes = 0; /* Various parameters */ @@ -62,9 +62,9 @@ static char *class_name = 0; static char *class_type = 0; static char *real_classname = 0; static char *base_class = 0; -static DOHHash *hash = 0; -static DOHHash *repeatcmd = 0; -static DOHHash *setget = 0; +static Hash *hash = 0; +static Hash *repeatcmd = 0; +static Hash *setget = 0; // --------------------------------------------------------------------- // TCL8::parse_args(int argc, char *argv[]) @@ -398,7 +398,9 @@ void TCL8::close(void) // Dump the pointer equivalency table - emit_type_table(f_runtime); + // emit_type_table(f_runtime); + + SwigType_emit_type_table(f_runtime, f_wrappers); // emit_ptr_equivalence(f_init); @@ -411,28 +413,28 @@ void TCL8::close(void) // ---------------------------------------------------------------------- // TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest, -// DataType *t, String &f, char *ret) +// SwigType *t, String &f, char *ret) // // iname = name of function or variable // srcname = name of source // src = source variable in wrapper code // dest = destination variable in wrapper code -// t = Datatype +// t = SwigType // f = String where output is going to go // ret = Return action // ---------------------------------------------------------------------- void TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest, - DataType *t, DOHString *f, char *ret) { + SwigType *t, String *f, char *ret) { // Pointers are read as hex-strings with encoded type information - DataType_remember(t); + SwigType_remember(t); Printv(f, tab4, "if ((SWIG_ConvertPtr(interp,", src, ",(void **) &", dest, ",",0); - if (DataType_type(t) == T_VOID) Printf(f, "0)) == TCL_ERROR) { return TCL_ERROR; }\n"); + if (SwigType_type(t) == T_VOID) Printf(f, "0)) == TCL_ERROR) { return TCL_ERROR; }\n"); else - Printv(f, "SWIGTYPE", DataType_manglestr(t), ")) == TCL_ERROR) { return TCL_ERROR; }\n", 0); + Printv(f, "SWIGTYPE", SwigType_manglestr(t), ")) == TCL_ERROR) { return TCL_ERROR; }\n", 0); } // ---------------------------------------------------------------------- @@ -443,33 +445,33 @@ void TCL8::get_pointer(char *iname, char *srcname, char *src, char *dest, void TCL8::create_command(char *cname, char *iname) { - char *wname = Swig_name_wrapper(cname); + String *wname = Swig_name_wrapper(cname); Printv(cmd_info, tab4, "{ SWIG_prefix \"", iname, "\", ", wname, ", NULL},\n", 0); // Add interpreter name to repeatcmd hash table. This hash is used in C++ code // generation to try and find repeated wrapper functions. - Setattr(repeatcmd,iname,wname); + Setattr(repeatcmd,iname,Char(wname)); } // ---------------------------------------------------------------------- -// TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) +// TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) // // Create a function declaration and register it with the interpreter. // ---------------------------------------------------------------------- -void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) +void TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) { Parm *p; int pcount,i,j; - char *wname; + char wname[256]; char *usage = 0, *tm; char source[64]; char target[64]; char argnum[32]; Wrapper *f; - DOHString *incode, *cleanup, *outarg, *argstr, *args; + String *incode, *cleanup, *outarg, *argstr, *args; int numopt= 0; f = NewWrapper(); @@ -481,7 +483,7 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // Make a wrapper name for this function - wname = Swig_name_wrapper(iname); + strcpy(wname, Char(Swig_name_wrapper(iname))); // Now write the wrapper function itself....this is pretty ugly @@ -507,12 +509,11 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) j = 0; p = l; while (p != 0) { - DataType *pt = Gettype(p); - char *pn = Getname(p); - + SwigType *pt = Gettype(p); + String *pn = Getname(p); // Produce string representations of the source and target arguments sprintf(source,"objv[%d]",j+1); - sprintf(target,"%s", Getlname(p)); + sprintf(target,"%s", Char(Getlname(p))); sprintf(argnum,"%d",j+1); // See if this argument is being ignored @@ -532,7 +533,7 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) } else { // Extract a parameter by value. - switch(DataType_type(pt)) { + switch(SwigType_type(pt)) { // Signed Integers case T_INT: case T_UINT: @@ -590,11 +591,11 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // User defined. This is an error. case T_USER: - DataType_add_pointer(pt); - DataType_remember(pt); + SwigType_add_pointer(pt); + SwigType_remember(pt); Putc('p',argstr); - Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0); - DataType_del_pointer(pt); + Printv(args, ",&", target, ", SWIGTYPE", SwigType_manglestr(pt), 0); + SwigType_del_pointer(pt); break; case T_STRING: @@ -603,16 +604,16 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) break; case T_POINTER: case T_ARRAY: case T_REFERENCE: - DataType_remember(pt); + SwigType_remember(pt); Putc('p',argstr); - Printv(args, ",&", target, ", SWIGTYPE", DataType_manglestr(pt), 0); + Printv(args, ",&", target, ", SWIGTYPE", SwigType_manglestr(pt), 0); break; // Unsupported data type default : Printf(stderr,"%s : Line %d: Unable to use type %s as a function argument.\n", - input_file, line_number, DataType_str(pt,0)); + input_file, line_number, SwigType_str(pt,0)); break; } } @@ -620,7 +621,7 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) } // Check to see if there was any sort of a constaint typemap - if ((tm = typemap_lookup((char*)"check",(char*)"tcl8",pt,pn,source,target))) { + if ((tm = typemap_lookup((char*)"check",(char*)"tcl8",pt,pn,source,target,0))) { // Yep. Use it instead of the default Printf(incode,"%s\n", tm); Replace(incode,"$argnum",argnum, DOH_REPLACE_ANY); @@ -628,14 +629,14 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) } // Check if there was any cleanup code (save it for later) - if ((tm = typemap_lookup((char*)"freearg",(char*)"tcl8",pt,pn,target,(char*)"tcl_result"))) { + if ((tm = typemap_lookup((char*)"freearg",(char*)"tcl8",pt,pn,target,(char*)"tcl_result",0))) { // Yep. Use it instead of the default Printf(cleanup,"%s\n", tm); Replace(cleanup,"$argnum",argnum, DOH_REPLACE_ANY); Replace(cleanup,"$arg",source,DOH_REPLACE_ANY); } // Look for output arguments - if ((tm = typemap_lookup((char*)"argout",(char*)"tcl8",pt,pn,target,(char*)"tcl_result"))) { + if ((tm = typemap_lookup((char*)"argout",(char*)"tcl8",pt,pn,target,(char*)"tcl_result",0))) { Printf(outarg,"%s\n", tm); Replace(outarg,"$argnum",argnum, DOH_REPLACE_ANY); Replace(outarg,"$arg",source, DOH_REPLACE_ANY); @@ -656,11 +657,11 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // Return value if necessary - if ((tm = typemap_lookup((char*)"out",(char*)"tcl8",d,name,(char*)"result",(char*)"tcl_result"))) { + if ((tm = typemap_lookup((char*)"out",(char*)"tcl8",d,name,(char*)"result",(char*)"tcl_result",0))) { // Yep. Use it instead of the default Printf(f->code,"%s\n", tm); } else { - switch(DataType_type(d)) { + switch(SwigType_type(d)) { case T_BOOL: case T_INT: case T_SHORT: @@ -690,12 +691,12 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // Okay. We're returning malloced memory at this point. // Probably dangerous, but who said safety was a good thing? - DataType_add_pointer(d); - DataType_remember(d); + SwigType_add_pointer(d); + SwigType_remember(d); Printv(f->code, tab4, "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) result,SWIGTYPE", - DataType_manglestr(d), "));\n", 0); + SwigType_manglestr(d), "));\n", 0); - DataType_del_pointer(d); + SwigType_del_pointer(d); break; case T_STRING: @@ -703,9 +704,9 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) Printv(f->code, tab4, "Tcl_SetObjResult(interp,Tcl_NewStringObj(result,-1));\n",0); break; case T_POINTER: case T_REFERENCE: case T_ARRAY: - DataType_remember(d); + SwigType_remember(d); Printv(f->code, tab4, "Tcl_SetObjResult(interp,SWIG_NewPointerObj((void *) result,SWIGTYPE", - DataType_manglestr(d), "));\n", + SwigType_manglestr(d), "));\n", 0); break; @@ -714,7 +715,7 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // Unknown type default : Printf(stderr,"%s : Line %d: Unable to use return type %s in function %s.\n", - input_file, line_number, DataType_str(d,0), name); + input_file, line_number, SwigType_str(d,0), name); break; } } @@ -728,12 +729,12 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) // Look for any remaining cleanup if (NewObject) { - if ((tm = typemap_lookup((char*)"newfree",(char*)"tcl8",d,iname,(char*)"result",(char*)""))) { + if ((tm = typemap_lookup((char*)"newfree",(char*)"tcl8",d,iname,(char*)"result",(char*)"",0))) { Printf(f->code,"%s\n", tm); } } - if ((tm = typemap_lookup((char*)"ret",(char*)"tcl8",d,name,(char*)"result",(char*)""))) { + if ((tm = typemap_lookup((char*)"ret",(char*)"tcl8",d,name,(char*)"result",(char*)"",0))) { // Yep. Use it instead of the default Printf(f->code,"%s\n", tm); } @@ -760,46 +761,46 @@ void TCL8::create_function(char *name, char *iname, DataType *d, ParmList *l) } // ----------------------------------------------------------------------- -// TCL8::link_variable(char *name, char *iname, DataType *t, int ex) +// TCL8::link_variable(char *name, char *iname, SwigType *t, int ex) // // Create a TCL link to a variable. // ----------------------------------------------------------------------- -void TCL8::link_variable(char *name, char *iname, DataType *t) +void TCL8::link_variable(char *name, char *iname, SwigType *t) { char *tm, *tm1; // See if there were any typemaps - tm = typemap_lookup((char*)"varin",(char*)"tcl8",t,name,(char*)"",(char*)""); - tm1 = typemap_lookup((char*)"varout",(char*)"tcl8",t,name,(char*)"",(char*)""); + tm = typemap_lookup((char*)"varin",(char*)"tcl8",t,name,(char*)"",(char*)"",0); + tm1 = typemap_lookup((char*)"varout",(char*)"tcl8",t,name,(char*)"",(char*)"",0); if (tm || tm1) { Printf(stderr,"%s : Line %d. Warning. varin/varout typemap methods not supported.", input_file, line_number); } // Dump a collection of set/get functions suitable for variable tracing - if (!Getattr(setget,DataType_str(t,0))) { - Setattr(setget,DataType_str(t,0),"1"); + if (!Getattr(setget,SwigType_lstr(t,0))) { + Setattr(setget,SwigType_lstr(t,0),"1"); Wrapper *get, *set; get = NewWrapper(); set = NewWrapper(); - Printv(set->def, "static char *_swig_", DataType_manglestr(t), "_set(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0); + Printv(set->def, "static char *_swig_", SwigType_manglestr(t), "_set(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0); - Printv(get->def, "static char *_swig_", DataType_manglestr(t), "_get(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0); - DataType_add_pointer(t); - Wrapper_add_localv(get,"addr",DataType_str(t,0),"addr",0); - Wrapper_add_localv(set,"addr",DataType_str(t,0),"addr",0); - Printv(set->code, tab4, "addr = (", DataType_lstr(t,0), ") clientData;\n", 0); - Printv(get->code, tab4, "addr = (", DataType_lstr(t,0), ") clientData;\n", 0); - DataType_del_pointer(t); + Printv(get->def, "static char *_swig_", SwigType_manglestr(t), "_get(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0); + SwigType_add_pointer(t); + Wrapper_add_localv(get,"addr",SwigType_lstr(t,0),"addr",0); + Wrapper_add_localv(set,"addr",SwigType_lstr(t,0),"addr",0); + Printv(set->code, tab4, "addr = (", SwigType_lstr(t,0), ") clientData;\n", 0); + Printv(get->code, tab4, "addr = (", SwigType_lstr(t,0), ") clientData;\n", 0); + SwigType_del_pointer(t); Wrapper_add_local(set, "value", "char *value"); Wrapper_add_local(get, "value", "Tcl_Obj *value"); Printv(set->code, tab4, "value = Tcl_GetVar2(interp, name1, name2, flags);\n", tab4, "if (!value) return NULL;\n", 0); - switch(DataType_type(t)) { + switch(SwigType_type(t)) { case T_INT: case T_SHORT: case T_USHORT: @@ -807,33 +808,33 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) case T_UCHAR: case T_SCHAR: case T_BOOL: - Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atol(value);\n", 0); + Printv(set->code, tab4, "*(addr) = (", SwigType_str(t,0), ") atol(value);\n", 0); break; case T_UINT: case T_ULONG: - Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") strtoul(value,0,0);\n",0); + Printv(set->code, tab4, "*(addr) = (", SwigType_str(t,0), ") strtoul(value,0,0);\n",0); break; case T_FLOAT: case T_DOUBLE: - Printv(set->code, tab4, "*(addr) = (", DataType_str(t,0), ") atof(value);\n",0); + Printv(set->code, tab4, "*(addr) = (", SwigType_str(t,0), ") atof(value);\n",0); break; case T_CHAR: /* Single character. */ Printv(set->code, tab4, "*(addr) = *value;\n",0); break; case T_USER: // User defined type. We return it as a pointer - DataType_add_pointer(t); - DataType_remember(t); + SwigType_add_pointer(t); + SwigType_remember(t); Printv(set->code, tab4, "{\n", tab8, "void *ptr;\n", - tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n", + tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", SwigType_manglestr(t), ") != TCL_OK) {\n", tab8, tab4, "return \"Type Error\";\n", tab8, "}\n", - tab8, "*(addr) = *((", DataType_lstr(t,0), ") ptr);\n", + tab8, "*(addr) = *((", SwigType_lstr(t,0), ") ptr);\n", tab4, "}\n", 0); - DataType_del_pointer(t); + SwigType_del_pointer(t); break; case T_STRING: Printv(set->code, tab4, "if (*addr) free(*addr);\n", @@ -843,13 +844,13 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) break; case T_POINTER: case T_ARRAY: case T_REFERENCE: // User defined type. We return it as a pointer - DataType_remember(t); + SwigType_remember(t); Printv(set->code, tab4, "{\n", tab8, "void *ptr;\n", - tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", DataType_manglestr(t), ") != TCL_OK) {\n", + tab8, "if (SWIG_ConvertPtrFromString(interp,value,&ptr,SWIGTYPE", SwigType_manglestr(t), ") != TCL_OK) {\n", tab8, tab4, "return \"Type Error\";\n", tab8, "}\n", - tab8, "*(addr) = (", DataType_lstr(t,0), ") ptr;\n", + tab8, "*(addr) = (", SwigType_lstr(t,0), ") ptr;\n", tab4, "}\n", 0); break; @@ -857,13 +858,13 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) break; default: - Printf(stderr,"Unknown type %s!\n", DataType_str(t,0)); + Printf(stderr,"Unknown type %s!\n", SwigType_str(t,0)); break; } Printv(set->code, tab4, "return NULL;\n", "}\n",0); - switch(DataType_type(t)) { + switch(SwigType_type(t)) { case T_INT: case T_UINT: case T_SHORT: @@ -899,12 +900,12 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) case T_USER: Wrapper_add_local(get,"value", "Tcl_Obj *value"); - DataType_add_pointer(t); - DataType_remember(t); - Printv(get->code, tab4, "value = SWIG_NewPointerObj(addr, SWIGTYPE", DataType_manglestr(t), ");\n", + SwigType_add_pointer(t); + SwigType_remember(t); + Printv(get->code, tab4, "value = SWIG_NewPointerObj(addr, SWIGTYPE", SwigType_manglestr(t), ");\n", tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n", tab4, "Tcl_DecrRefCount(value);\n",0); - DataType_del_pointer(t); + SwigType_del_pointer(t); break; case T_STRING: @@ -913,9 +914,9 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) case T_POINTER: case T_ARRAY: case T_REFERENCE: Wrapper_add_local(get,"value","Tcl_Obj *value"); - DataType_remember(t); + SwigType_remember(t); Printv(get->code, - tab4, "value = SWIG_NewPointerObj(*addr, SWIGTYPE", DataType_manglestr(t), ");\n", + tab4, "value = SWIG_NewPointerObj(*addr, SWIGTYPE", SwigType_manglestr(t), ");\n", tab4, "Tcl_SetVar2(interp,name1,name2,Tcl_GetStringFromObj(value,NULL), flags);\n", tab4, "Tcl_DecrRefCount(value);\n", 0); @@ -930,7 +931,7 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) DelWrapper(get); DelWrapper(set); } - Printv(var_info, tab4,"{ SWIG_prefix \"", iname, "\", (void *) &", name, ", _swig_", DataType_manglestr(t), "_get,", 0); + Printv(var_info, tab4,"{ SWIG_prefix \"", iname, "\", (void *) &", name, ", _swig_", SwigType_manglestr(t), "_get,", 0); if (Status & STAT_READONLY) { static int readonly = 0; @@ -944,25 +945,25 @@ void TCL8::link_variable(char *name, char *iname, DataType *t) } Printf(var_info, "_swig_readonly},\n"); } else { - Printv(var_info, "_swig_", DataType_manglestr(t), "_set},\n",0); + Printv(var_info, "_swig_", SwigType_manglestr(t), "_set},\n",0); } } // ----------------------------------------------------------------------- -// TCL8::declare_const(char *name, char *iname, DataType *type, char *value) +// TCL8::declare_const(char *name, char *iname, SwigType *type, char *value) // // Makes a constant. Really just creates a variable and links to it. // Tcl variable linkage allows read-only variables so we'll use that // instead of just creating a Tcl variable. // ------------------------------------------------------------------------ -void TCL8::declare_const(char *name, char *, DataType *type, char *value) { +void TCL8::declare_const(char *name, char *, SwigType *type, char *value) { int OldStatus = Status; // Save old status flags - DataType *t; + SwigType *t; char var_name[256]; char *tm; - DOHString *rvalue; + String *rvalue; Status = STAT_READONLY; // Enable readonly mode. // Make a static variable; @@ -970,28 +971,28 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) { sprintf(var_name,"_wrap_const_%s",name); // See if there's a typemap - if (DataType_type(type) == T_STRING) { + if (SwigType_type(type) == T_STRING) { rvalue = NewStringf("\"%s\"",value); - } else if (DataType_type(type) == T_CHAR) { + } else if (SwigType_type(type) == T_CHAR) { rvalue = NewStringf("\'%s\'",value); } else { rvalue = NewString(value); } - if ((tm = typemap_lookup((char*)"const",(char*)"tcl8",type,name,Char(rvalue),name))) { + if ((tm = typemap_lookup((char*)"const",(char*)"tcl8",type,name,Char(rvalue),name,0))) { // Yep. Use it instead of the default Printf(f_init,"%s\n",tm); } else { // Create variable and assign it a value - switch(DataType_type(type)) { + switch(SwigType_type(type)) { case T_BOOL: case T_INT: case T_DOUBLE: - Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value); + Printf(f_header,"static %s %s = %s;\n", SwigType_str(type,0), var_name, value); link_variable(var_name,name,type); break; case T_SHORT: case T_LONG: case T_SCHAR: - Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value); + Printf(f_header,"static %s %s = %s;\n", SwigType_str(type,0), var_name, value); Printf(f_header,"static char *%s_char;\n", var_name); if (CPlusPlus) Printf(f_init,"\t %s_char = new char[32];\n",var_name); @@ -1000,16 +1001,16 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) { Printf(f_init,"\t sprintf(%s_char,\"%%ld\", (long) %s);\n", var_name, var_name); sprintf(var_name,"%s_char",var_name); - t = NewDataType(T_CHAR); - DataType_add_pointer(t); + t = NewString("char"); + SwigType_add_pointer(t); link_variable(var_name,name,t); - DelDataType(t); + Delete(t); break; case T_UINT: case T_USHORT: case T_ULONG: case T_UCHAR: - Printf(f_header,"static %s %s = %s;\n", DataType_str(type,0), var_name, value); + Printf(f_header,"static %s %s = %s;\n", SwigType_str(type,0), var_name, value); Printf(f_header,"static char *%s_char;\n", var_name); if (CPlusPlus) Printf(f_init,"\t %s_char = new char[32];\n",var_name); @@ -1018,47 +1019,45 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) { Printf(f_init,"\t sprintf(%s_char,\"%%lu\", (unsigned long) %s);\n", var_name, var_name); sprintf(var_name,"%s_char",var_name); - t = NewDataType(T_CHAR); - DataType_add_pointer(t); + t = NewSwigType(T_CHAR); + SwigType_add_pointer(t); link_variable(var_name,name,t); - DelDataType(t); + Delete(t); break; case T_FLOAT: - DataType_Settypecode(type,T_DOUBLE); - DataType_Setname(type,"double"); - Printf(f_header,"static %s %s = (%s) (%s);\n", DataType_lstr(type,0), var_name, DataType_lstr(type,0), value); + 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); break; case T_CHAR: - DataType_add_pointer(type); - Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value); + 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); - DataType_del_pointer(type); + SwigType_del_pointer(type); break; case T_STRING: - Printf(f_header,"static %s %s = \"%s\";\n", DataType_lstr(type,0), var_name, value); + Printf(f_header,"static %s %s = \"%s\";\n", SwigType_lstr(type,0), var_name, value); link_variable(var_name,name,type); break; case T_POINTER: case T_ARRAY: case T_REFERENCE: // Something else. Some sort of pointer value - Printf(f_header,"static %s %s = %s;\n", DataType_lstr(type,0), var_name, value); + Printf(f_header,"static %s %s = %s;\n", SwigType_lstr(type,0), var_name, value); Printf(f_header,"static char *%s_char;\n", var_name); if (CPlusPlus) - Printf(f_init,"\t %s_char = new char[%d];\n",var_name,(int) strlen(DataType_manglestr(type))+ 20); + Printf(f_init,"\t %s_char = new char[%d];\n",var_name,(int) Len(SwigType_manglestr(type))+ 20); else - Printf(f_init,"\t %s_char = (char *) malloc(%d);\n",var_name, (int) strlen(DataType_manglestr(type))+ 20); + Printf(f_init,"\t %s_char = (char *) malloc(%d);\n",var_name, (int) Len(SwigType_manglestr(type))+ 20); - t = NewDataType(T_CHAR); - DataType_add_pointer(t); - DataType_remember(type); + t = NewSwigType(T_CHAR); + SwigType_add_pointer(t); + SwigType_remember(type); Printf(f_init,"\t SWIG_MakePtr(%s_char, (void *) %s, SWIGTYPE%s);\n", - var_name, var_name, DataType_manglestr(type)); + var_name, var_name, SwigType_manglestr(type)); sprintf(var_name,"%s_char",var_name); link_variable(var_name,name,t); - DelDataType(t); + Delete(t); break; default: Printf(stderr,"%s : Line %d. Unsupported constant value.\n", input_file, line_number); @@ -1070,12 +1069,12 @@ void TCL8::declare_const(char *name, char *, DataType *type, char *value) { } // ---------------------------------------------------------------------- -// TCL8::usage_var(char *iname, DataType *t, char **s) +// TCL8::usage_var(char *iname, SwigType *t, char **s) // // Produces a usage string for a tcl variable. Stores it in s // ---------------------------------------------------------------------- -char *TCL8::usage_var(char *iname, DataType *t) { +char *TCL8::usage_var(char *iname, SwigType *t) { static char temp[2048]; @@ -1090,14 +1089,14 @@ char *TCL8::usage_var(char *iname, DataType *t) { // --------------------------------------------------------------------------- -// char *TCL8::usage_string(char *iname, DataType *t, ParmList *l), +// char *TCL8::usage_string(char *iname, SwigType *t, ParmList *l), // // Generates a generic usage string for a Tcl function. // --------------------------------------------------------------------------- -char * TCL8::usage_string(char *iname, DataType *, ParmList *l) { +char * TCL8::usage_string(char *iname, SwigType *, ParmList *l) { - static DOHString *temp = 0; + static String *temp = 0; Parm *p; int i, numopt,pcount; @@ -1112,8 +1111,8 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) { p = l; while (p != 0) { - DataType *pt = Gettype(p); - char *pn = Getname(p); + SwigType *pt = Gettype(p); + String *pn = Getname(p); // Only print an argument if not ignored @@ -1122,12 +1121,12 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) { Putc('?',temp); /* If parameter has been named, use that. Otherwise, just print a type */ - if (DataType_type(pt) != T_VOID) { - if (strlen(pn) > 0) { - Printf(temp,pn); + if (SwigType_type(pt) != T_VOID) { + if (Len(pn) > 0) { + Printf(temp,"%s",pn); } else { - Printf(temp,"{ %s }", DataType_str(pt,0)); + Printf(temp,"%s", SwigType_str(pt,0)); } } if (i >= (pcount-numopt)) @@ -1141,12 +1140,12 @@ char * TCL8::usage_string(char *iname, DataType *, ParmList *l) { } // --------------------------------------------------------------------------- -// char *TCL8::usage_func(char *iname, DataType *t, ParmList *l), +// char *TCL8::usage_func(char *iname, SwigType *t, ParmList *l), // // Produces a usage string for a function in Tcl // --------------------------------------------------------------------------- -char * TCL8::usage_func(char *iname, DataType *t, ParmList *l) { +char * TCL8::usage_func(char *iname, SwigType *t, ParmList *l) { char temp[1024]; if (nspace) { @@ -1158,13 +1157,13 @@ char * TCL8::usage_func(char *iname, DataType *t, ParmList *l) { } // ----------------------------------------------------------------- -// TCL8::usage_const(char *name, DataType *type, char *value) +// TCL8::usage_const(char *name, SwigType *type, char *value) // char **s) // // Makes a usage string and returns it // ----------------------------------------------------------------- -char *TCL8::usage_const(char *name, DataType *, char *value) { +char *TCL8::usage_const(char *name, SwigType *, char *value) { static char temp[1024]; if (nspace) { sprintf(temp,"%s::%s = %s", ns_name,name,value); @@ -1175,14 +1174,14 @@ char *TCL8::usage_const(char *name, DataType *, char *value) { } // ------------------------------------------------------------------- -// TCL8::add_native(char *name, char *funcname, DataType *t, ParmList *l) +// TCL8::add_native(char *name, char *funcname, SwigType *t, ParmList *l) // // This adds an already written Tcl wrapper function to our // initialization function. // ------------------------------------------------------------------- -void TCL8::add_native(char *name, char *funcname, DataType *, ParmList *) { +void TCL8::add_native(char *name, char *funcname, SwigType *, ParmList *) { Printf(f_init,"\t Tcl_CreateObjCommand(%s, SWIG_prefix \"%s\", %s, (ClientData) NULL, (Tcl_CmdDeleteProc *) NULL);\n",interp_name, name, funcname); @@ -1247,23 +1246,20 @@ void TCL8::cpp_open_class(char *classname, char *rename, char *ctype, int strip) } void TCL8::cpp_close_class() { - DOHString *code; - DataType *t; + String *code; + SwigType *t; code = NewString(""); this->Language::cpp_close_class(); if (shadow) { - char temp[256]; - t = NewDataType(T_USER); - sprintf(temp,"%s%s", class_type, real_classname); - DataType_Setname(t,temp); - DataType_add_pointer(t); + t = NewStringf("%s%s", class_type, real_classname); + SwigType_add_pointer(t); if (have_destructor) { Printv(code, "static void _swig_delete_", class_name, "(void *obj) {\n", 0); if (CPlusPlus) { - Printv(code," delete (", DataType_str(t,0), ") obj;\n",0); + Printv(code," delete (", SwigType_str(t,0), ") obj;\n",0); } else { Printv(code," free((char *) obj);\n",0); } @@ -1277,10 +1273,10 @@ void TCL8::cpp_close_class() { Printv(code,attributes,0); Printv(code, "static _swig_class _wrap_class_", class_name, " = { \"", class_name, - "\", &SWIGTYPE", DataType_manglestr(t), ",",0); + "\", &SWIGTYPE", SwigType_manglestr(t), ",",0); if (have_constructor) { - Printf(code, Swig_name_wrapper(Swig_name_construct(class_name))); + Printf(code, "%s", Swig_name_wrapper(Swig_name_construct(class_name))); } else { Printf(code,"0"); } @@ -1298,7 +1294,7 @@ void TCL8::cpp_close_class() { } -void TCL8::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) { +void TCL8::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) { char *realname; char temp[1024]; @@ -1314,16 +1310,16 @@ void TCL8::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) { // Add stubs for this member to our class handler function - strcpy(temp, Swig_name_member(class_name,realname)); + strcpy(temp, Char(Swig_name_member(class_name,realname))); rname = GetChar(repeatcmd,temp); if (!rname) - rname = Swig_name_wrapper(temp); + rname = Char(Swig_name_wrapper(temp)); Printv(methods, tab4, "{\"", realname, "\", ", rname, "}, \n", 0); } } -void TCL8::cpp_variable(char *name, char *iname, DataType *t) { +void TCL8::cpp_variable(char *name, char *iname, SwigType *t) { char *realname; char temp[1024]; char *rname; @@ -1341,17 +1337,17 @@ void TCL8::cpp_variable(char *name, char *iname, DataType *t) { Printv(attributes, tab4, "{ \"-", realname, "\",", 0); // Try to figure out if there is a wrapper for this function - strcpy(temp, Swig_name_get(Swig_name_member(bc,realname))); + strcpy(temp, Char(Swig_name_get(Swig_name_member(bc,realname)))); rname = GetChar(repeatcmd,temp); if (!rname) - rname = Swig_name_wrapper(temp); + rname = Char(Swig_name_wrapper(temp)); Printv(attributes, rname, ", ", 0); if (!(Status & STAT_READONLY)) { - strcpy(temp, Swig_name_set(Swig_name_member(bc,realname))); + strcpy(temp, Char(Swig_name_set(Swig_name_member(bc,realname)))); rname = GetChar(repeatcmd,temp); if (!rname) - rname = Swig_name_wrapper(temp); + rname = Char(Swig_name_wrapper(temp)); Printv(attributes, rname, "},\n",0); } else { Printf(attributes, "0 },\n"); @@ -1377,12 +1373,12 @@ void TCL8::cpp_inherit(char **baseclass, int) { this->Language::cpp_inherit(baseclass); } -void TCL8::cpp_declare_const(char *name, char *iname, DataType *type, char *value) { +void TCL8::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) { this->Language::cpp_declare_const(name,iname,type,value); } // -------------------------------------------------------------------------------- -// TCL8::add_typedef(DataType *t, char *name) +// TCL8::add_typedef(SwigType *t, char *name) // // This is called whenever a typedef is encountered. When shadow classes are // used, this function lets us discovered hidden uses of a class. For example : @@ -1395,22 +1391,22 @@ void TCL8::cpp_declare_const(char *name, char *iname, DataType *type, char *valu // // -------------------------------------------------------------------------------- -void TCL8::add_typedef(DataType *t, char *name) { +void TCL8::add_typedef(SwigType *t, char *name) { if (!shadow) return; // First check to see if there aren't too many pointers - if (DataType_is_pointer(t) > 1) return; + if (SwigType_ispointer(t) > 1) return; if (Getattr(hash,name)) return; // Already added // Now look up the datatype in our shadow class hash table - if (Getattr(hash,DataType_Getname(t))) { + if (Getattr(hash,t)) { // Yep. This datatype is in the hash // Put this types 'new' name into the hash - Setattr(hash,name,GetChar(hash,DataType_Getname(t))); + Setattr(hash,name,GetChar(hash,t)); } } diff --git a/Source/Modules1.1/tcl8.h b/Source/Modules1.1/tcl8.h index 23aa5c2fa..b4fbeaa0b 100644 --- a/Source/Modules1.1/tcl8.h +++ b/Source/Modules1.1/tcl8.h @@ -22,26 +22,26 @@ class TCL8 : public Language { private: - void get_pointer(char *iname, char *srcname, char *src, char *dest, DataType *t, + void get_pointer(char *iname, char *srcname, char *src, char *dest, SwigType *t, DOHString *f, char *ret); char *char_result; - char *usage_func(char *, DataType *, ParmList *); - char *usage_string(char *, DataType *, ParmList *); - char *usage_var(char *, DataType *); - char *usage_const(char *, DataType *, char *); + char *usage_func(char *, SwigType *, ParmList *); + char *usage_string(char *, SwigType *, ParmList *); + char *usage_var(char *, SwigType *); + char *usage_const(char *, SwigType *, char *); public : virtual void parse_args(int, char *argv[]); virtual void parse(); - virtual void create_function(char *, char *, DataType *, ParmList *); - virtual void link_variable(char *, char *, DataType *); - virtual void declare_const(char *, char *, DataType *, char *); + 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 initialize(void); virtual void headers(void); virtual void close(void); virtual void set_module(char *,char **); virtual void set_init(char *); - virtual void add_native(char *, char *, DataType *, ParmList *); + virtual void add_native(char *, char *, SwigType *, ParmList *); virtual void pragma(char *,char *, char *); virtual void create_command(char *, char *); @@ -49,13 +49,13 @@ public : virtual void cpp_open_class(char *classname, char *rename, char *ctype, int strip); virtual void cpp_close_class(); - virtual void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); - virtual void cpp_variable(char *name, char *iname, DataType *t); + virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); + virtual void cpp_variable(char *name, char *iname, SwigType *t); virtual void cpp_constructor(char *name, char *iname, ParmList *l); virtual void cpp_destructor(char *name, char *newname); virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); - virtual void cpp_declare_const(char *name, char *iname, DataType *type, char *value); - virtual void add_typedef(DataType *, char *); + virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); + virtual void add_typedef(SwigType *, char *); virtual void cpp_class_decl(char *, char *, char *); }; diff --git a/Source/SWIG1.1/cplus.cxx b/Source/SWIG1.1/cplus.cxx index f7ac6e402..a23f0e876 100644 --- a/Source/SWIG1.1/cplus.cxx +++ b/Source/SWIG1.1/cplus.cxx @@ -94,18 +94,18 @@ static int cpp_id = 0; // Forward references -void cplus_member_func(char *, char *, DataType *, ParmList *, int); +void cplus_member_func(char *, char *, SwigType *, ParmList *, int); void cplus_constructor(char *, char *, ParmList *); void cplus_destructor(char *, char *); -void cplus_variable(char *, char *, DataType *); -void cplus_static_func(char *, char *, DataType *, ParmList *); -void cplus_declare_const(char *, char *, DataType *, char *); -void cplus_static_var(char *, char *, DataType *); +void cplus_variable(char *, char *, SwigType *); +void cplus_static_func(char *, char *, SwigType *, ParmList *); +void cplus_declare_const(char *, char *, SwigType *, char *); +void cplus_static_var(char *, char *, SwigType *); void cplus_inherit_decl(char **); // ----------------------------------------------------------------------------- // void add_local_type(char *type, char *classname) -// void add_local_type(DataType *type, char *classname) +// void add_local_type(SwigType *type, char *classname) // // Adds a new datatype to the local datatype hash. This is used to handle // datatypes defined within a class. @@ -118,19 +118,19 @@ static void add_local_type(char *type, char *classname) { Setattr(localtypes,type,str); } -void add_local_type(DataType *type, char *classname) { - add_local_type(DataType_Getname(type),classname); +void add_local_type(SwigType *type, char *classname) { + add_local_type(Char(type),classname); } // ----------------------------------------------------------------------------- -// void update_local_type(DataType *type) +// void update_local_type(SwigType *type) // // Checks to see whether this datatype is part of a class definition. If so, // we update the type-name by appending the class prefix to it. Uses the // name stored in current_class unless unavailable. // ----------------------------------------------------------------------------- -static void update_local_type(DataType *type) { +static void update_local_type(SwigType *type) { char *newname = 0; @@ -138,9 +138,9 @@ static void update_local_type(DataType *type) { if (!localtypes) return; - newname = GetChar(localtypes,DataType_Getname(type)); + newname = GetChar(localtypes,SwigType_base(type)); if (newname) { - DataType_Setname(type,newname); + SwigType_setbase(type,newname); } } @@ -153,8 +153,8 @@ static void update_local_type(DataType *type) { static void update_parms(ParmList *p) { while (p) { - DataType *pt = Gettype(p); - char *pvalue = Getvalue(p); + SwigType *pt = Gettype(p); + DOHString *pvalue = Getvalue(p); update_local_type(pt); @@ -202,15 +202,15 @@ public: class CPP_function : public CPP_member { public: - DataType *ret_type; + SwigType *ret_type; ParmList *parms; int new_object; int is_virtual; - CPP_function(char *n, char *i, DataType *t, ParmList *l, int s, int v = 0) { + CPP_function(char *n, char *i, SwigType *t, ParmList *l, int s, int v = 0) { name = Swig_copy_string(n); iname = Swig_copy_string(i); - ret_type = CopyDataType(t); + ret_type = Copy(t); parms = CopyParmList(l); is_static = s; is_virtual = v; @@ -220,11 +220,7 @@ public: next = 0; line = line_number; file = input_file; - if (Inherit_mode) { - id = cpp_id; - } else { - id = type_id; - } + id = cpp_id; if (AddMethods) { if (strlen(Char(CCode))) code = Swig_copy_string(Char(CCode)); @@ -255,7 +251,7 @@ public: } void emit() { ParmList *l; - DataType *t; + SwigType *t; AddMethods = new_method; NewObject = new_object; line_number = line; // Restore line and file @@ -266,7 +262,7 @@ public: // Make a copy of the parameter list and upgrade its types l = CopyParmList(parms); - t = CopyDataType(ret_type); + t = Copy(ret_type); update_parms(l); update_local_type(t); if (is_static) { @@ -275,7 +271,7 @@ public: lang->cpp_member_func(name, iname, t, l); } Delete(l); - DelDataType(t); + Delete(t); IsVirtual = 0; } }; @@ -298,7 +294,7 @@ public: next = 0; line = line_number; file = input_file; - id = type_id; + id = 0; if (AddMethods) { if (strlen(Char(CCode))) code = Swig_copy_string(Char(CCode)); @@ -344,7 +340,7 @@ public: inherited = 0; line = line_number; file = input_file; - id = type_id; + id = 0; if (AddMethods) { if (strlen(Char(CCode))) code = Swig_copy_string(Char(CCode)); @@ -372,12 +368,12 @@ public: class CPP_variable : public CPP_member { public: - DataType *type; + SwigType *type; int status; - CPP_variable(char *n, char *i, DataType *t, int s) { + CPP_variable(char *n, char *i, SwigType *t, int s) { name = Swig_copy_string(n); iname = Swig_copy_string(i); - type = CopyDataType(t); + type = Copy(t); is_static = s; status = Status; next = 0; @@ -387,7 +383,7 @@ public: if (Inherit_mode) { id = cpp_id; } else { - id = type_id; + id = 0; } code = 0; inherited = 0; @@ -396,7 +392,7 @@ public: // Emit code for this void emit() { - DataType *t; + SwigType *t; int old_status = Status; AddMethods = new_method; Status = status; @@ -404,7 +400,7 @@ public: input_file = file; ccode = code; - t = CopyDataType(type); + t = Copy(type); update_local_type(t); if (!is_static) { lang->cpp_variable(name,iname,t); @@ -412,7 +408,7 @@ public: lang->cpp_static_var(name,iname,t); } Status = old_status; - DelDataType(t); + Delete(t); } // Inherit into another class @@ -446,11 +442,11 @@ public: class CPP_constant : public CPP_member { public: char *value; - DataType *type; - CPP_constant(char *n, char *i, DataType *t, char *v) { + SwigType *type; + CPP_constant(char *n, char *i, SwigType *t, char *v) { name = Swig_copy_string(n); iname = Swig_copy_string(i); - type = CopyDataType(t); + type = Copy(t); value = Swig_copy_string(v); new_method = AddMethods; next = 0; @@ -459,7 +455,7 @@ public: if (Inherit_mode) id = cpp_id; else - id = type_id; + id = 0; code = 0; inherited = 0; } @@ -753,8 +749,8 @@ void cplus_open_class(char *name, char *rname, char *ctype) { if (strlen(name)) { if (strlen(ctype) > 0) { sprintf(temp,"%s %s", ctype, name); - typeeq_derived(temp,name,0); // Map "struct foo" to "foo" - typeeq_derived(name,temp,0); // Map "foo" to "struct foo" + // typeeq_derived(temp,name,0); // Map "struct foo" to "foo" + //typeeq_derived(name,temp,0); // Map "foo" to "struct foo" } } } @@ -976,6 +972,7 @@ void cplus_generate_types(char **baseclass) { // Write a function for casting derived type to parent class +#ifdef OLD Printv(cfunc, "static void *Swig", current_class->classname, "To", bc->classname, "(void *ptr) {\n", @@ -986,8 +983,8 @@ void cplus_generate_types(char **baseclass) { tab4, "return (void *) dest;\n", "}\n", 0); - Printf(f_wrappers,"%s\n",Char(cfunc)); +#endif } } else { Clear(temp3); @@ -1002,14 +999,15 @@ void cplus_generate_types(char **baseclass) { // Add various equivalences to the pointer table - typeeq_derived(bc->classname, current_class->classname,Char(temp3)); - typeeq_derived(temp2, current_class->classname,Char(temp3)); - typeeq_derived(temp2, temp1,Char(temp3)); - typeeq_derived(bc->classname, temp1,Char(temp3)); + // typeeq_derived(bc->classname, current_class->classname,Char(temp3)); + // typeeq_derived(temp2, current_class->classname,Char(temp3)); + // typeeq_derived(temp2, temp1,Char(temp3)); + // typeeq_derived(bc->classname, temp1,Char(temp3)); } else { - typeeq_derived(bc->classname, current_class->classname,Char(temp3)); + // typeeq_derived(bc->classname, current_class->classname,Char(temp3)); } - DataType_record_base(current_class->classname, bc->classname); + // DataType_record_base(current_class->classname, bc->classname); + SwigType_inherit(current_class->classname, bc->classname); // Now traverse the hierarchy some more cplus_generate_types(bc->baseclass); } @@ -1105,7 +1103,7 @@ void cplus_inherit_members(char *baseclass, int mode) { // Adds member function to current class. // ----------------------------------------------------------------------------- -void cplus_member_func(char *name, char *iname, DataType *type, ParmList *l, +void cplus_member_func(char *name, char *iname, SwigType *type, ParmList *l, int is_virtual) { CPP_function *f; @@ -1193,14 +1191,14 @@ void cplus_destructor(char *name, char *iname) { } // ----------------------------------------------------------------------------- -// void cplus_variable(char *name, char *iname, DataType *t) +// void cplus_variable(char *name, char *iname, SwigType *t) // // Parser entry point for creating a new member variable. // // Inputs : // name = name of the variable // iname = Renamed version (may be NULL) -// t = Datatype +// t = SwigType // // Output : None // @@ -1208,7 +1206,7 @@ void cplus_destructor(char *name, char *iname) { // Adds a member variable to the current class // ----------------------------------------------------------------------------- -void cplus_variable(char *name, char *iname, DataType *t) { +void cplus_variable(char *name, char *iname, SwigType *t) { CPP_variable *v; char *temp_iname; @@ -1231,14 +1229,14 @@ void cplus_variable(char *name, char *iname, DataType *t) { } // ----------------------------------------------------------------------------- -// void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l) +// void cplus_static_func(char *name, char *iname, SwigType *type, ParmList *l) // // Parser entry point for creating a new static member function. // // Inputs : // name = Real name of the function // iname = Renamed version (may be NULL) -// type = Return datatype +// type = Return SwigType // l = Parameter list // // Output : None @@ -1248,7 +1246,7 @@ void cplus_variable(char *name, char *iname, DataType *t) { // // ----------------------------------------------------------------------------- -void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l) { +void cplus_static_func(char *name, char *iname, SwigType *type, ParmList *l) { char *temp_iname; @@ -1269,7 +1267,7 @@ void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l) { } // ----------------------------------------------------------------------------- -// void cplus_declare_const(char *name, char *iname, DataType *type, char *value) +// void cplus_declare_const(char *name, char *iname, SwigType *type, char *value) // // Parser entry point for creating a C++ constant (usually contained in an // enum). @@ -1286,7 +1284,7 @@ void cplus_static_func(char *name, char *iname, DataType *type, ParmList *l) { // Adds a constant to the current class. // ----------------------------------------------------------------------------- -void cplus_declare_const(char *name, char *iname, DataType *type, char *value) { +void cplus_declare_const(char *name, char *iname, SwigType *type, char *value) { char *temp_iname; @@ -1310,7 +1308,7 @@ void cplus_declare_const(char *name, char *iname, DataType *type, char *value) { } // ----------------------------------------------------------------------------- -// void cplus_static_var(char *name, char *iname, DataType *type) +// void cplus_static_var(char *name, char *iname, SwigType *type) // // Parser entry point for adding a static variable // @@ -1325,7 +1323,7 @@ void cplus_declare_const(char *name, char *iname, DataType *type, char *value) { // Adds a static variable to the current class. // ----------------------------------------------------------------------------- -void cplus_static_var(char *name, char *iname, DataType *type) { +void cplus_static_var(char *name, char *iname, SwigType *type) { char *temp_iname; @@ -1394,7 +1392,7 @@ static DOHHash *member_hash = 0; // Hash wrapping member function wrappers to s // ----------------------------------------------------------------------------- // void cplus_emit_member_func(char *classname, char *classtype, char *classrename, -// char *mname, char *mrename, DataType *type, +// char *mname, char *mrename, SwigType *type, // ParmList *l, int mode) // // This is a generic function to produce a C wrapper around a C++ member function. @@ -1469,7 +1467,7 @@ static DOHHash *member_hash = 0; // Hash wrapping member function wrappers to s // ----------------------------------------------------------------------------- void cplus_emit_member_func(char *classname, char *classtype, char *classrename, - char *mname, char *mrename, DataType *type, ParmList *l, + char *mname, char *mrename, SwigType *type, ParmList *l, int mode) { Wrapper *w; @@ -1491,7 +1489,7 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename, if (!classrename) classrename = classname; if (!mrename) mrename = mname; - strcpy(iname, Swig_name_member(classrename, mrename)); + strcpy(iname, Char(Swig_name_member(classrename, mrename))); char *bc = cplus_base_class(mrename); if (!bc) bc = classname; @@ -1523,7 +1521,7 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename, // ----------------------------------------------------------------------------- // void cplus_emit_static_func(char *classname, char *classtype, char *classrename, -// char *mname, char *mrename, DataType *type, +// char *mname, char *mrename, SwigType *type, // ParmList *l, int mode) // // This is a generic function to produce a wrapper for a C++ static member function @@ -1572,7 +1570,7 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename, // ----------------------------------------------------------------------------- void cplus_emit_static_func(char *classname, char *, char *classrename, - char *mname, char *mrename, DataType *type, ParmList *l, + char *mname, char *mrename, SwigType *type, ParmList *l, int mode) { char cname[512], iname[512]; @@ -1593,12 +1591,12 @@ void cplus_emit_static_func(char *classname, char *, char *classrename, if ((!mode) && (!ObjCClass)) { sprintf(cname,"%s::%s", bc, mname); } else { - strcpy(cname,Swig_name_member(bc,mname)); + strcpy(cname,Char(Swig_name_member(bc,mname))); } // Generate the scripting name of this function if (!classrename) classrename = classname; - strcpy(iname,Swig_name_member(classrename, mrename)); + strcpy(iname,Char(Swig_name_member(classrename, mrename))); // Perform a hash table lookup to see if we've wrapped anything like this before Printf(key,"%s+%s",cname, ParmList_str(l)); @@ -1615,7 +1613,7 @@ void cplus_emit_static_func(char *classname, char *, char *classrename, lang->create_function(cname,iname, type, l); } else { if (!ccode) { - strcpy(cname, Swig_name_member(classname,mname)); + strcpy(cname, Char(Swig_name_member(classname,mname))); lang->create_function(cname,iname, type, l); } else { Wrapper *w = Swig_cfunction_wrapper(cname, type, l, ccode); @@ -1673,11 +1671,11 @@ void cplus_emit_destructor(char *classname, char *classtype, char *classrename, if (!classrename) classrename = classname; - strcpy(cname,Swig_name_destroy(classname)); + strcpy(cname,Char(Swig_name_destroy(classname))); if (mrename) - strcpy(iname, Swig_name_destroy(mrename)); + strcpy(iname, Char(Swig_name_destroy(mrename))); else - strcpy(iname, Swig_name_destroy(classrename)); + strcpy(iname, Char(Swig_name_destroy(classrename))); sprintf(fclassname,"%s%s", classtype, classname); if (CPlusPlus) { @@ -1730,11 +1728,11 @@ void cplus_emit_constructor(char *classname, char *classtype, char *classrename, // Construct names for the function if (!classrename) classrename = classname; - strcpy(cname,Swig_name_construct(classname)); + strcpy(cname,Char(Swig_name_construct(classname))); if (mrename) - strcpy(iname, Swig_name_construct(mrename)); + strcpy(iname, Char(Swig_name_construct(mrename))); else - strcpy(iname, Swig_name_construct(classrename)); + strcpy(iname, Char(Swig_name_construct(classrename))); sprintf(fclassname,"%s%s", classtype, classname); @@ -1761,7 +1759,7 @@ void cplus_emit_constructor(char *classname, char *classtype, char *classrename, // ----------------------------------------------------------------------------- // void cplus_emit_variable_get(char *classname, char *classtype, char *classrename, -// char *mname, char *mrename, DataType *type, int mode) +// char *mname, char *mrename, SwigType *type, int mode) // // Writes a C wrapper to extract a data member // @@ -1800,7 +1798,7 @@ void cplus_emit_constructor(char *classname, char *classtype, char *classrename, // ----------------------------------------------------------------------------- void cplus_emit_variable_get(char *classname, char *classtype, char *classrename, - char *mname, char *mrename, DataType *type, int mode) { + char *mname, char *mrename, SwigType *type, int mode) { char cname[512],iname[512], fclassname[512]; char key[512]; @@ -1819,11 +1817,11 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename // Generate the name of the C wrapper function (is always the same, regardless // of renaming). - strcpy(cname, Swig_name_get(Swig_name_member(bc,mname))); + strcpy(cname, Char(Swig_name_get(Swig_name_member(bc,mname)))); // Generate the scripting name of this function if (!classrename) classrename = classname; - strcpy(iname, Swig_name_get(Swig_name_member(classrename,mrename))); + strcpy(iname, Char(Swig_name_get(Swig_name_member(classrename,mrename)))); // Now check to see if we have already wrapped a variable like this. @@ -1855,7 +1853,7 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename // ----------------------------------------------------------------------------- // void cplus_emit_variable_set(char *classname, char *classtype, char *mname, -// char *cname, char *iname, DataType *type, int mode) +// char *cname, char *iname, SwigType *type, int mode) // // Writes a C wrapper to set a data member // @@ -1903,7 +1901,7 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename // ----------------------------------------------------------------------------- void cplus_emit_variable_set(char *classname, char *classtype, char *classrename, - char *mname, char *mrename, DataType *type, int mode) { + char *mname, char *mrename, SwigType *type, int mode) { char cname[512], iname[512]; char key[512]; @@ -1920,10 +1918,10 @@ void cplus_emit_variable_set(char *classname, char *classtype, char *classrename // Generate the name of the C wrapper function (is always the same, regardless // of renaming). - strcpy(cname, Swig_name_set(Swig_name_member(bc,mname))); + strcpy(cname, Char(Swig_name_set(Swig_name_member(bc,mname)))); if (!classrename) classrename = classname; - strcpy(iname, Swig_name_set(Swig_name_member(classrename, mrename))); + strcpy(iname, Char(Swig_name_set(Swig_name_member(classrename, mrename)))); // Now check to see if we have already wrapped a variable like this. @@ -2028,9 +2026,9 @@ void cplus_inherit_scope(int count, char **baseclass) { for (i = 0; i < count; i++) { bc = CPP_class::search(baseclass[i]); if (bc) { - if (bc->scope) - DataType_merge_scope(bc->scope); - + if (bc->scope) { + SwigType_merge_scope(bc->scope,0); + } if (bc->local) { // Copy local symbol table key = Firstkey(bc->local); diff --git a/Source/SWIG1.1/emit.cxx b/Source/SWIG1.1/emit.cxx index bca37de2f..516a4abb1 100644 --- a/Source/SWIG1.1/emit.cxx +++ b/Source/SWIG1.1/emit.cxx @@ -20,7 +20,7 @@ extern "C" { static char cvsroot[] = "$Header$"; /* ----------------------------------------------------------------------------- - * int emit_args(char *d, DataType *rt, ParmList *l, Wrapper *f) + * emit_args() * * Creates a list of variable declarations for both the return value * and function parameters. @@ -29,15 +29,15 @@ static char cvsroot[] = "$Header$"; * Returns the number of parameters associated with a function. * ----------------------------------------------------------------------------- */ -int emit_args(DataType *rt, ParmList *l, Wrapper *f) { +int emit_args(SwigType *rt, ParmList *l, Wrapper *f) { Parm *p; int i; char *tm; - DataType *pt; - char *pvalue; - char *pname; - char *lname; + SwigType *pt; + DOHString *pvalue; + DOHString *pname; + DOHString *lname; /* Emit function arguments */ Swig_cargs(f, l); @@ -89,13 +89,13 @@ void emit_set_action(DOHString_or_char *decl) { fcall = NewString(decl); } -void emit_func_call(char *decl, DataType *t, ParmList *l, Wrapper *f) { +void emit_func_call(char *decl, SwigType *t, ParmList *l, Wrapper *f) { char *tm; - if ((tm = typemap_lookup((char*)"except",typemap_lang,t,decl,(char*)"result",(char*)""))) { + if ((tm = typemap_lookup((char*)"except",typemap_lang,t,decl,(char*)"result",(char*)"",0))) { Printv(f->code,tm,0); Replace(f->code,"$name",decl,DOH_REPLACE_ANY); - } else if ((tm = fragment_lookup((char*)"except",typemap_lang, t->_id))) { + } else if ((tm = fragment_lookup((char*)"except",typemap_lang))) { Printv(f->code,tm,0); Replace(f->code,"$name",decl,DOH_REPLACE_ANY); } else { @@ -150,16 +150,16 @@ strcpy((char *)$target,$source);\n\ return ($ltype) $target;\n;"; -void emit_set_get(char *name, char *iname, DataType *t) { +void emit_set_get(char *name, char *iname, SwigType *t) { Wrapper *w; - char new_iname[256]; + DOHString *new_iname; char *code = 0; /* First write a function to set the variable of the variable */ if (!(Status & STAT_READONLY)) { - if (DataType_type(t) == T_STRING) { + if (SwigType_type(t) == T_STRING) { if (CPlusPlus) code = cpp_str; else @@ -167,15 +167,19 @@ void emit_set_get(char *name, char *iname, DataType *t) { } w = Swig_cvarset_wrapper(name, t, code); Wrapper_print(w,f_header); - strcpy(new_iname, Swig_name_set(iname)); - lang->create_function(Wrapper_Getname(w), new_iname, Wrapper_Gettype(w), Wrapper_Getparms(w)); + new_iname = Swig_name_set(iname); + DohIncref(new_iname); + lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w)); + Delete(new_iname); DelWrapper(w); } w = Swig_cvarget_wrapper(name,t,0); Wrapper_print(w,f_header); - strcpy(new_iname, Swig_name_get(iname)); - lang->create_function(Wrapper_Getname(w), new_iname, Wrapper_Gettype(w), Wrapper_Getparms(w)); + new_iname = Swig_name_get(iname); + DohIncref(new_iname); + lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w)); + Delete(new_iname); DelWrapper(w); } diff --git a/Source/SWIG1.1/internal.h b/Source/SWIG1.1/internal.h index f3babbc54..d86530c7f 100644 --- a/Source/SWIG1.1/internal.h +++ b/Source/SWIG1.1/internal.h @@ -39,3 +39,4 @@ struct TMParm { #define NI_NAMES 512 + diff --git a/Source/SWIG1.1/lang.cxx b/Source/SWIG1.1/lang.cxx index a3a73c84e..ce4e6d728 100644 --- a/Source/SWIG1.1/lang.cxx +++ b/Source/SWIG1.1/lang.cxx @@ -24,19 +24,14 @@ extern "C" { extern int add_symbol(char *name); /* ----------------------------------------------------------------- - * void Language::set_init(char *iname) - * - * Called to make an initialization function by %init (obsolete) + * Language::set_init() * ----------------------------------------------------------------- */ - void Language::set_init(char *iname) { set_module(iname,0); } /* ----------------------------------------------------------------- - * void Language::create_command(char *cname, char *iname - * - * Method for adding a previous wrapped C function. + * Language::create_command() * ----------------------------------------------------------------- */ void Language::create_command(char *, char *) { @@ -45,14 +40,11 @@ void Language::create_command(char *, char *) { } /* ----------------------------------------------------------------- - * void Language::add_native(char *name, char *iname, DataType *t, ParmList *l) - * - * Method for adding a native function with full argument info - * default is to call the old-style add_native method + * Language::add_native() * ----------------------------------------------------------------- */ void -Language::add_native(char *, char *iname, DataType *, ParmList *) { +Language::add_native(char *, char *iname, SwigType *, ParmList *) { Printf(stderr,"%s : Line %d. Adding native function %s not supported (ignored).\n", input_file, line_number, iname); } @@ -61,20 +53,7 @@ static char *ClassRename = 0; /* This is non-NULL if the class has been re static char *ClassType = 0; /* Type of class (ie. union, struct, class) */ /* ----------------------------------------------------------------------------- - * void Language::cpp_open_class(char *classname, char *classrename, char *ctype, int strip) - * - * Open a new C++ class. - * - * INPUTS: - * classname = Real name of the C++ class - * classrename = New name of the class (if %name was used) - * ctype = Class type (struct, class, union, etc...) - * strip = Flag indicating whether we should strip the class type off - * - * This function is in charge of creating a new class. The SWIG parser has - * already processed the entire class definition prior to calling this - * function (which should simplify things considerably). - * + * Language::cpp_open_class() * ----------------------------------------------------------------------------- */ void Language::cpp_open_class(char *classname, char *classrename, char *ctype, int strip) { @@ -102,9 +81,7 @@ void Language::cpp_open_class(char *classname, char *classrename, char *ctype, i } /* ----------------------------------------------------------------------------- - * void Language::cpp_close_class() - * - * Close the current class + * Language::cpp_close_class() * ----------------------------------------------------------------------------- */ void Language::cpp_close_class() { @@ -114,28 +91,10 @@ void Language::cpp_close_class() { } /* ----------------------------------------------------------------------------- - * void Language::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) - * - * Method for adding C++ member function - * - * INPUTS: - * name - name of the member function - * iname - renaming (if given) - * t - Return datatype - * l - Parameter list - * - * By default, we're going to create a function of the form : - * - * Foo_bar(this,args) - * - * Where Foo is the classname, bar is the member name and the this pointer is - * explicitly attached to the beginning. - * - * The renaming only applies to the member function part, not the full classname. - * + * Language::cpp_member_func() * ----------------------------------------------------------------------------- */ -void Language::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) { +void Language::cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l) { char cname[256]; /* Name of the C function */ char new_name[256]; char *prefix; @@ -154,19 +113,19 @@ void Language::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l if (AddMethods) { char *bc = cplus_base_class(name); /* Get base class name of this method */ if (bc) - strcpy(cname, Swig_name_member(bc,name)); + strcpy(cname, Char(Swig_name_member(bc,name))); else - strcpy(cname, Swig_name_member(ClassName,name)); + strcpy(cname, Char(Swig_name_member(ClassName,name))); } else { - strcpy(cname, Swig_name_member(ClassName,name)); + strcpy(cname, Char(Swig_name_member(ClassName,name))); } /* Create the actual function name */ if (iname) { - strcpy(new_name, Swig_name_member(prefix,iname)); + strcpy(new_name, Char(Swig_name_member(prefix,iname))); } else { - strcpy(new_name, Swig_name_member(prefix,name)); + strcpy(new_name, Char(Swig_name_member(prefix,name))); } /* Now do a symbol table lookup on it : */ @@ -180,14 +139,7 @@ void Language::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l } /* ----------------------------------------------------------------------------- - * void Language::cpp_constructor(char *name, char *iname, ParmList *l) - * - * Method for adding C++ member constructor - * - * INPUTS: - * name - Name of the constructor (usually same as classname) - * iname - Renamed version - * l - parameters + * Language::cpp_constructor() * ----------------------------------------------------------------------------- */ void Language::cpp_constructor(char *name, char *iname, ParmList *l) { @@ -208,9 +160,9 @@ void Language::cpp_constructor(char *name, char *iname, ParmList *l) { prefix = ClassName; if (iname) - cname = Swig_name_construct(iname); + cname = Char(Swig_name_construct(iname)); else - cname = Swig_name_construct(prefix); + cname = Char(Swig_name_construct(prefix)); /* Add this function to the SWIG symbol table */ @@ -227,14 +179,7 @@ void Language::cpp_constructor(char *name, char *iname, ParmList *l) { } /* ----------------------------------------------------------------------------- - * void Language::cpp_destructor(char *name, char *iname) - * - * Method for adding C++ member destructor - * - * INPUT: - * name - Name of the destructor (classname) - * iname - Renamed destructor - * + * Language::cpp_destructor() * ----------------------------------------------------------------------------- */ void Language::cpp_destructor(char *name, char *iname) { @@ -242,9 +187,9 @@ void Language::cpp_destructor(char *name, char *iname) { char *cname; if (ClassRename) - cname = Swig_name_destroy(ClassRename); + cname = Char(Swig_name_destroy(ClassRename)); else - cname = Swig_name_destroy(ClassName); + cname = Char(Swig_name_destroy(ClassName)); /* Add this function to the SWIG symbol table */ @@ -262,9 +207,7 @@ void Language::cpp_destructor(char *name, char *iname) { } /* ----------------------------------------------------------------------------- - * void Language::cleanup() - * - * Perform any necessary cleanup after reaching end of interface file + * Language::cleanup() * ----------------------------------------------------------------------------- */ void Language::cpp_cleanup() { @@ -274,13 +217,7 @@ void Language::cpp_cleanup() { } /* ----------------------------------------------------------------------------- - * void Language::cpp_inherit(char **baseclass, int mode) - * - * Inherit attributes from given baseclass. - * - * INPUT: - * baseclass = NULL terminate list of baseclasses - * + * Language::cpp_inherit() * ----------------------------------------------------------------------------- */ void Language::cpp_inherit(char **baseclass, int mode) { @@ -296,19 +233,10 @@ void Language::cpp_inherit(char **baseclass, int mode) { } /* ----------------------------------------------------------------------------- - * void Language::cpp_variable(char *name, char *iname, DataType *t) - * - * Wrap a C++ data member - * - * INPUTS : - * name = Name of the C++ member - * iname = Name as used in the interpreter - * t = Datatype - * - * This creates a pair of functions to set/get the variable of a member. + * Language::cpp_variable() * ----------------------------------------------------------------------------- */ -void Language::cpp_variable(char *name, char *iname, DataType *t) { +void Language::cpp_variable(char *name, char *iname, SwigType *t) { char *prefix, *cname; /* Set the class prefix */ @@ -320,9 +248,9 @@ void Language::cpp_variable(char *name, char *iname, DataType *t) { } if (iname) - cname = Swig_name_get(Swig_name_member(prefix,iname)); + cname = Char(Swig_name_get(Swig_name_member(prefix,iname))); else - cname = Swig_name_get(Swig_name_member(prefix,name)); + cname = Char(Swig_name_get(Swig_name_member(prefix,name))); /* Check the symbol table */ @@ -344,18 +272,10 @@ void Language::cpp_variable(char *name, char *iname, DataType *t) { } /* ----------------------------------------------------------------------------- - * void Language::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) - * - * Wrap a static C++ function - * - * INPUTS: - * name = Real name of the function - * iname = New name in interpreter - * t = Return datatype - * l = Parameters + * Language::cpp_static_func() * ----------------------------------------------------------------------------- */ -void Language::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l) { +void Language::cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) { char *prefix; char *mname; @@ -375,7 +295,7 @@ void Language::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l else mname = name; - cname = Swig_name_member(prefix,mname); + cname = Char(Swig_name_member(prefix,mname)); /* Now do a symbol table lookup on it : */ @@ -393,19 +313,10 @@ void Language::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l } /* ----------------------------------------------------------------------------- - * void Language::cpp_declare_const(char *name, char *iname, DataType *t, char *value) - * - * Create a C++ constant - * - * INPUTS : - * name = Real name of the constant - * iname = new name - * t = Datatype - * value = value as a string - * + * Language::cpp_declare_const() * ----------------------------------------------------------------------------- */ -void Language::cpp_declare_const(char *name, char *iname, DataType *type, char *value) +void Language::cpp_declare_const(char *name, char *iname, SwigType *type, char *value) { char *cname; @@ -424,9 +335,9 @@ void Language::cpp_declare_const(char *name, char *iname, DataType *type, char * /* Set the constant name */ if (iname) - cname = Swig_name_member(prefix,iname); + cname = Char(Swig_name_member(prefix,iname)); else - cname = Swig_name_member(prefix,name); + cname = Char(Swig_name_member(prefix,name)); /* Now do a symbol table lookup on it : */ @@ -456,18 +367,10 @@ void Language::cpp_declare_const(char *name, char *iname, DataType *type, char * } /* ----------------------------------------------------------------------------- - * void Language::cpp_static_var(char *name, char *iname, DataType *t) - * - * Wrap a static C++ variable - * - * INPUT : - * name = name of the variable - * iname = interpreter name - * t = Datatype - * + * Language::cpp_static_var() * ----------------------------------------------------------------------------- */ -void Language::cpp_static_var(char *name, char *iname, DataType *t) { +void Language::cpp_static_var(char *name, char *iname, SwigType *t) { char *cname; char mname[256]; @@ -484,9 +387,9 @@ void Language::cpp_static_var(char *name, char *iname, DataType *t) { /* Create the variable name */ if (iname) - cname = Swig_name_member(prefix,iname); + cname = Char(Swig_name_member(prefix,iname)); else - cname = Swig_name_member(prefix,name); + cname = Char(Swig_name_member(prefix,name)); /* Now do a symbol table lookup on it : */ @@ -506,21 +409,15 @@ void Language::cpp_static_var(char *name, char *iname, DataType *t) { } /* ----------------------------------------------------------------------------- - * void Language::cpp_class_decl(char *classtype, char *classrename, char *classname) - * - * A forward class declaration + * Language::cpp_class_decl() * ----------------------------------------------------------------------------- */ void Language::cpp_class_decl(char *, char *, char *) { - /* Does nothing by default */ - } /* ----------------------------------------------------------------------------- - * void Language::cpp_pragma(Pragma *plist) - * - * Handler C++ pragmas + * Language::cpp_pragma() * ----------------------------------------------------------------------------- */ void Language::cpp_pragma(Pragma *) { @@ -528,45 +425,25 @@ void Language::cpp_pragma(Pragma *) { } /* ----------------------------------------------------------------------------- - * void Language::add_typedef(DataType *t, char *name) - * - * Process a typedef declaration. + * Language::add_typedef() * ----------------------------------------------------------------------------- */ -void Language::add_typedef(DataType *, char *) { - +void Language::add_typedef(SwigType *, char *) { + /* Does nothing by default */ } - /* ----------------------------------------------------------------------------- - * void Language::pragma(char *target, char *var, char *value) - * - * A pragma declaration + * Language::pragma() * ----------------------------------------------------------------------------- */ void Language::pragma(char *, char *, char *) { - /* Does nothing by default */ - } /* ----------------------------------------------------------------------------- - * void Language::import(char *filename) - * - * An import directive + * Language::import() * ----------------------------------------------------------------------------- */ void Language::import(char *) { - /* Does nothing by default */ - } - - - - - - - - - diff --git a/Source/SWIG1.1/main.cxx b/Source/SWIG1.1/main.cxx index 9af142908..4bcb8bdef 100644 --- a/Source/SWIG1.1/main.cxx +++ b/Source/SWIG1.1/main.cxx @@ -129,12 +129,9 @@ static int freeze = 0; int SWIG_main(int argc, char *argv[], Language *l) { int i; char *c; - extern FILE *LEX_in; - extern char *get_time(); char temp[512]; char infile[512]; char *outfile_name = 0; - extern int add_iname(char *); int help = 0; int checkout = 0; int cpp_only = 0; @@ -143,9 +140,8 @@ int SWIG_main(int argc, char *argv[], Language *l) { int includecount = 0; extern int check_suffix(char *); extern void scanner_file(DOHFile *); - extern void typemap_initialize(void); extern void parser_init(void); - + extern void typemap_initialize(); DOH *libfiles = 0; { @@ -166,7 +162,7 @@ int SWIG_main(int argc, char *argv[], Language *l) { lang = l; Status = 0; - DataType_init_typedef(); // Initialize the type handler + // DataType_init_typedef(); // Initialize the type handler // Set up some default symbols (available in both SWIG interface files // and C files) @@ -418,6 +414,7 @@ int SWIG_main(int argc, char *argv[], Language *l) { f_init = NewString(""); // Set up the typemap for handling new return strings +#ifdef OLD { DataType *temp_t = NewDataType(T_CHAR); DataType_add_pointer(temp_t); @@ -428,6 +425,7 @@ int SWIG_main(int argc, char *argv[], Language *l) { DelDataType(temp_t); } +#endif // If in Objective-C mode. Load in a configuration file diff --git a/Source/SWIG1.1/parser.yxx b/Source/SWIG1.1/parser.yxx index 931c00e90..96d128f89 100644 --- a/Source/SWIG1.1/parser.yxx +++ b/Source/SWIG1.1/parser.yxx @@ -62,13 +62,13 @@ static int lang_init = 0; /* Indicates if the language has been initial static int i; int Error = 0; static char temp_name[128]; -static DataType *temp_typeptr, *temp_type = 0; +static SwigType *temp_typeptr, *temp_type = 0; static char yy_rename[256]; static int Rename_true = 0; -static DataType *Active_type = 0; // Used to support variable lists +static SwigType *Active_type = 0; // Used to support variable lists static int Active_extern = 0; // Whether or not list is external static int Active_static = 0; -static DataType *Active_typedef = 0; // Used for typedef lists +static SwigType *Active_typedef = 0; // Used for typedef lists static int InArray = 0; // Used when an array declaration is found static DOHString *ArrayString = 0; // Array type attached to parameter names static DOHString *ArrayBackup = 0; @@ -98,16 +98,16 @@ int cplus_mode; // Declarations of some functions for handling C++ extern void cplus_open_class(char *name, char *rname, char *ctype); -extern void cplus_member_func(char *, char *, DataType *, ParmList *, int); +extern void cplus_member_func(char *, char *, SwigType *, ParmList *, int); extern void cplus_constructor(char *, char *, ParmList *); extern void cplus_destructor(char *, char *); -extern void cplus_variable(char *, char *, DataType *); -extern void cplus_static_func(char *, char *, DataType *, ParmList *); -extern void cplus_declare_const(char *, char *, DataType *, char *); +extern void cplus_variable(char *, char *, SwigType *); +extern void cplus_static_func(char *, char *, SwigType *, ParmList *); +extern void cplus_declare_const(char *, char *, SwigType *, char *); extern void cplus_class_close(char *); extern void cplus_inherit(int, char **); extern void cplus_cleanup(void); -extern void cplus_static_var(char *, char *, DataType *); +extern void cplus_static_var(char *, char *, SwigType *); extern void cplus_register_type(char *); extern void cplus_register_scope(void *); extern void cplus_inherit_scope(int, char **); @@ -118,7 +118,7 @@ extern void cplus_abort(); void parser_init() { ArrayString = NewString(""); - temp_type = NewDataType(0); + temp_type = NewString(""); } static TMParm *NewTMParm() { @@ -127,10 +127,10 @@ static TMParm *NewTMParm() { return tmp; } -static void add_pointers(DataType *t, int npointer) { +static void add_pointers(SwigType *t, int npointer) { int i; for (i = 0; i < npointer; i++) { - DataType_add_pointer(t); + SwigType_add_pointer(t); } } @@ -201,24 +201,24 @@ static void format_string(char *str) { // Emit an external function declaration -static void emit_extern_func(char *decl, DataType *t, ParmList *L, int extern_type, DOHFile *f) { +static void emit_extern_func(char *decl, SwigType *t, ParmList *L, int extern_type, DOHFile *f) { switch(extern_type) { case 0: - Printf(f,"%s", DataType_str(t,0)); + Printf(f,"%s", SwigType_str(t,0)); Printf(f,"%s(%s);\n", decl, ParmList_protostr(L)); break; case 1: - Printf(f,"extern %s", DataType_str(t,0)); + Printf(f,"extern %s", SwigType_str(t,0)); Printf(f,"%s(%s);\n", decl, ParmList_protostr(L)); break; case 2: /* A C++ --- > C Extern */ - Printf(f,"extern \"C\" %s", DataType_str(t,0)); + Printf(f,"extern \"C\" %s", SwigType_str(t,0)); Printf(f,"%s(%s);\n", decl, ParmList_protostr(L)); break; case 3: - Printf(f,"%s", DataType_str(t,0)); + Printf(f,"%s", SwigType_str(t,0)); Printf(f,"%s(%s)\n", decl, ParmList_str(L)); break; default: @@ -309,7 +309,7 @@ static char *make_name(char *name) { // only used internally to the parser. // ---------------------------------------------------------------------- -void create_function(int ext, char *name, DataType *t, ParmList *l) { +void create_function(int ext, char *name, SwigType *t, ParmList *l) { if (Active_static) return; // Static declaration. Ignore init_language(); @@ -344,11 +344,9 @@ void create_function(int ext, char *name, DataType *t, ParmList *l) { // Create a link to a global variable. // ------------------------------------------------------------------- -void create_variable(int ext, char *name, DataType *t) { +void create_variable(int ext, char *name, SwigType *t) { if (WrapExtern) return; // External wrapper file. Ignore - int oldstatus = Status; - if (Active_static) return; // If static ignore init_language(); @@ -362,15 +360,11 @@ void create_variable(int ext, char *name, DataType *t) { // If externed, output an external declaration if (ext || ForceExtern) { - Printf(f_header,"extern %s;\n", DataType_str(t,name)); + Printf(f_header,"extern %s;\n", SwigType_str(t,name)); } - // If variable datatype is read-only, we'll force it to be readonly - if (t->_status & STAT_READONLY) Status = Status | STAT_READONLY; - // Now dump it out lang->link_variable(name, iname, t); - Status = oldstatus; } scanner_clear_start(); } @@ -381,7 +375,7 @@ void create_variable(int ext, char *name, DataType *t) { // Creates a new constant. // ------------------------------------------------------------------- -void create_constant(char *name, DataType *type, char *value) { +void create_constant(char *name, SwigType *type, char *value) { if (Active_static) return; if (WrapExtern) return; // External wrapper file. Ignore @@ -393,8 +387,8 @@ void create_constant(char *name, DataType *type, char *value) { Rename_true = 0; } - if (DataType_type(type) == T_CHAR) { - DataType_add_pointer(type); + if (SwigType_type(type) == T_CHAR) { + SwigType_add_pointer(type); } if (!value) value = Swig_copy_string(name); sprintf(temp_name,"const:%s", name); @@ -423,7 +417,7 @@ struct Nested { DOHString *code; // Associated code fragment int line; // line number where it starts char *name; // Name associated with this nested class - DataType *type; // Datatype associated with the name + SwigType *type; // Datatype associated with the name Nested *next; // Next code fragment in list }; @@ -460,7 +454,10 @@ static void dump_nested(char *parent) { // Fix up the name of the datatype (for building typedefs and other stuff) sprintf(temp,"%s_%s", parent,n->name); - DataType_Setname(n->type,temp); + + Append(n->type,parent); + Append(n->type,"_"); + Append(n->type,n->name); // Add the appropriate declaration to the C++ processor cplus_variable(n->name,(char *) 0, n->type); @@ -479,6 +476,15 @@ static void dump_nested(char *parent) { Status = oldstatus; } + static DOHList *typelist(Parm *p) { + DOHList *l = NewList(); + while (p) { + Append(l,Gettype(p)); + p = Getnext(p); + } + return l; + } + %} /* The type of each node in the parse tree @@ -512,7 +518,7 @@ static void dump_nested(char *parent) { int line; int flag; } loc; - DataType *type; + SwigType *type; Parm *p; TMParm *tmparm; ParmList *pl; @@ -525,7 +531,7 @@ static void dump_nested(char *parent) { %token INCLUDE IMPORT WEXTERN SWIGMACRO %token NUM_INT NUM_FLOAT CHARCONST NUM_UNSIGNED NUM_LONG NUM_ULONG %token TYPEDEF -%token TYPE_INT TYPE_UNSIGNED TYPE_SHORT TYPE_LONG TYPE_FLOAT TYPE_DOUBLE TYPE_CHAR TYPE_VOID TYPE_SIGNED TYPE_BOOL TYPE_TYPEDEF +%token TYPE_INT TYPE_UNSIGNED TYPE_SHORT TYPE_LONG TYPE_FLOAT TYPE_DOUBLE TYPE_CHAR TYPE_VOID TYPE_SIGNED TYPE_BOOL TYPE_TYPEDEF TYPE_RAW %token LPAREN RPAREN COMMA SEMI EXTERN INIT LBRACE RBRACE DEFINE PERIOD %token CONST STRUCT UNION EQUAL SIZEOF MODULE LBRACKET RBRACKET %token ILLEGAL CONSTANT @@ -652,31 +658,24 @@ statement : INCLUDE STRING LBRACE { | extern type declaration array2 def_args { init_language(); - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($2); - Active_extern = $1; - add_pointers($2,$3.is_pointer); + if (Active_type) Delete(Active_type); + Active_type = Copy($2); + Active_extern = $1; + add_pointers($2,$3.is_pointer); if ($4 > 0) { - DataType_add_pointer($2); - $2->_status = STAT_READONLY; - DataType_set_arraystr($2,Char(ArrayString)); + SwigType_push($2,ArrayString); } if ($3.is_reference) { Printf(stderr,"%s : Line %d. Error. Linkage to C++ reference not allowed.\n", input_file, line_number); FatalError(); } else { - if (DataType_qualifier($2)) { - if (strcmp(DataType_qualifier($2),"const") == 0) { - if ($5.type != T_ERROR) - create_constant($3.id, $2, $5.id); - } else { - create_variable($1,$3.id,$2); - } + if (SwigType_isconst($2)) { + create_constant($3.id, $2, $5.id); } else { create_variable($1,$3.id,$2); } } - DelDataType($2); + Delete($2); } stail { } /* Global variable that smells like a function pointer */ @@ -691,7 +690,7 @@ statement : INCLUDE STRING LBRACE { | STATIC type declaration array2 def_args { Active_static = 1; - DelDataType($2); + Delete($2); } stail { Active_static = 0; } @@ -709,13 +708,13 @@ statement : INCLUDE STRING LBRACE { | extern type declaration LPAREN parms RPAREN cpp_const { init_language(); - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($2); + if (Active_type) Delete(Active_type); + Active_type = Copy($2); Active_extern = $1; add_pointers($2,$3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); create_function($1, $3.id, $2, $5); - DelDataType($2); + Delete($2); Delete($5); } stail { } @@ -723,22 +722,22 @@ statement : INCLUDE STRING LBRACE { | extern type declaration LPAREN parms RPAREN func_end { init_language(); - if ($3.is_reference) DataType_add_reference($2); add_pointers($2,$3.is_pointer); - create_function($1, $3.id, $2, $5); - DelDataType($2); + if ($3.is_reference) SwigType_add_reference($2); + create_function($1, $3.id, $2, $5); + Delete($2); Delete($5); }; /* A function declared without any return datatype */ | extern declaration LPAREN parms RPAREN cpp_const { - init_language(); - DataType *t = NewDataType(T_INT); + init_language(); + SwigType *t = NewString("int"); add_pointers(t,$2.is_pointer); - if ($2.is_reference) DataType_add_reference(t); - create_function($1,$2.id,t,$4); - DelDataType(t); + if ($2.is_reference) SwigType_add_reference(t); + create_function($1,$2.id,t,$4); + Delete(t); } stail { }; /* A static function declaration code after it */ @@ -748,11 +747,11 @@ statement : INCLUDE STRING LBRACE { if (strlen(Char(CCode))) { init_language(); add_pointers($2, $3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); create_function(0, $3.id, $2, $5); } } - DelDataType($2); + Delete($2); Delete($5); }; @@ -761,7 +760,7 @@ statement : INCLUDE STRING LBRACE { | INLINE type declaration LPAREN parms RPAREN func_end { init_language(); add_pointers($2,$3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); if (Inline) { Printf(stderr,"%s : Line %d. Repeated %%inline directive.\n",input_file,line_number); FatalError(); @@ -773,7 +772,7 @@ statement : INCLUDE STRING LBRACE { } create_function(0, $3.id, $2, $5); } - DelDataType($2); + Delete($2); Delete($5); }; @@ -781,7 +780,7 @@ statement : INCLUDE STRING LBRACE { | STATIC type declaration LPAREN parms RPAREN cpp_const { Active_static = 1; - DelDataType($2); + Delete($2); Delete($5); } stail { Active_static = 0; @@ -856,7 +855,7 @@ statement : INCLUDE STRING LBRACE { lang->add_native($3,$7.id,$6,$9); } } - DelDataType($6); + Delete($6); Delete($9); } @@ -993,9 +992,9 @@ statement : INCLUDE STRING LBRACE { | CONSTANT ID definetype SEMI { if (($3.type != T_ERROR) && ($3.type != T_SYMBOL)) { init_language(); - temp_typeptr = NewDataType($3.type); + temp_typeptr = NewSwigType($3.type); create_constant($2, temp_typeptr, $3.id); - DelDataType(temp_typeptr); + Delete(temp_typeptr); } else if ($3.type == T_SYMBOL) { // Add a symbol to the SWIG symbol table if (add_symbol($2)) { @@ -1005,14 +1004,22 @@ statement : INCLUDE STRING LBRACE { } } + | CONSTANT LPAREN parm RPAREN ID def_args SEMI { + if (($6.type != T_ERROR) && ($6.type != T_SYMBOL)) { + init_language(); + create_constant($5,Gettype($3), $6.id); + Delete($3); + } + } + /* Enumerations */ | extern ENUM ename LBRACE { scanner_clear_start(); } enumlist RBRACE SEMI { init_language(); if ($3) { - if (temp_type) DelDataType(temp_type); - temp_type = NewDataType(T_INT); - DataType_typedef_add(temp_type,$3,1); + if (temp_type) Delete(temp_type); + temp_type = NewSwigType(T_INT); + SwigType_typedef(temp_type,$3); lang->add_typedef(temp_type,$3); } } @@ -1021,10 +1028,10 @@ statement : INCLUDE STRING LBRACE { | TYPEDEF ENUM ename LBRACE { scanner_clear_start(); } enumlist RBRACE ID { init_language(); - if (temp_type) DelDataType(temp_type); - temp_type = NewDataType(T_INT); - Active_typedef = CopyDataType(temp_type); - DataType_typedef_add(temp_type,$8,1); + if (temp_type) Delete(temp_type); + temp_type = NewSwigType(T_INT); + Active_typedef = Copy(temp_type); + SwigType_typedef(temp_type,$8); lang->add_typedef(temp_type,$8); } typedeflist { } @@ -1177,12 +1184,12 @@ statement : INCLUDE STRING LBRACE { /* Clear an exception */ | EXCEPT LPAREN ID RPAREN SEMI { - fragment_clear((char *) "except",$3); + fragment_clear((char *) "except",$3); } /* Generic clear */ | EXCEPT SEMI { - fragment_clear((char *) "except",typemap_lang); + fragment_clear((char *) "except",typemap_lang); } /* Miscellaenous stuff */ @@ -1244,13 +1251,10 @@ doc_enable : DOC_DISABLE { typedef_decl : TYPEDEF type declaration { init_language(); /* Add a new typedef */ - Active_typedef = CopyDataType($2); + Active_typedef = Copy($2); add_pointers($2,$3.is_pointer); - DataType_typedef_add($2, $3.id,0); + SwigType_typedef($2, $3.id); lang->add_typedef($2,$3.id); - /* If this is %typedef, add it to the header */ - if ($1) - Printf(f_header,"typedef %s;\n", DataType_str($2,$3.id)); cplus_register_type($3.id); } typedeflist { }; @@ -1259,59 +1263,46 @@ typedef_decl : TYPEDEF type declaration { | TYPEDEF type LPAREN STAR pname RPAREN LPAREN parms RPAREN SEMI { init_language(); /* Typedef'd pointer */ - if ($1) { - sprintf(temp_name,"(*%s)",$5); - Printf(f_header,"typedef "); - emit_extern_func(temp_name, $2,$8,0,f_header); - } - DataType_Setname($2,""); - DataType_Settypecode($2,T_USER); - DataType_add_pointer($2); - DataType_typedef_add($2,$5,1); + DOHList *l = typelist($8); + SwigType_add_function($2,l); + SwigType_add_pointer($2); + SwigType_typedef($2,$5); lang->add_typedef($2,$5); cplus_register_type($5); - DelDataType($2); - free($5); - Delete($8); + Delete($2); + free($5); + Delete($8); + Delete(l); } /* A typedef involving function pointers again */ | TYPEDEF type stars LPAREN STAR pname RPAREN LPAREN parms RPAREN SEMI { init_language(); - if ($1) { - add_pointers($2,$3); - sprintf(temp_name,"(*%s)",$6); - Printf(f_header,"typedef "); - emit_extern_func(temp_name, $2,$9,0,f_header); - } - - /* Typedef'd pointer */ - DataType_Setname($2,""); - DataType_Settypecode($2,T_USER); - DataType_typedef_add($2,$6,1); + add_pointers($2,$3); + DOHList *l = typelist($9); + SwigType_add_function($2,l); + SwigType_add_pointer($2); + SwigType_typedef($2,$6); lang->add_typedef($2,$6); cplus_register_type($6); - DelDataType($2); - free($6); - Delete($9); + Delete($2); + free($6); + Delete($9); + Delete(l); } /* A typedef involving arrays */ | TYPEDEF type declaration array { init_language(); - Active_typedef = CopyDataType($2); + Active_typedef = Copy($2); // This datatype is going to be readonly - $2->_status = STAT_READONLY | STAT_REPLACETYPE; add_pointers($2,$3.is_pointer); - // Turn this into a "pointer" corresponding to the array - DataType_add_pointer($2); - DataType_set_arraystr($2,Char(ArrayString)); - DataType_typedef_add($2,$3.id,0); + SwigType_push($2,ArrayString); + SwigType_typedef($2,$3.id); lang->add_typedef($2,$3.id); - Printf(stderr,"%s : Line %d. Warning. Array type %s will be read-only without a typemap\n",input_file,line_number, $3.id); cplus_register_type($3.id); } typedeflist { } @@ -1329,25 +1320,24 @@ typedef_decl : TYPEDEF type declaration { typedeflist : COMMA declaration typedeflist { if (Active_typedef) { - DataType *t; - t = CopyDataType(Active_typedef); + SwigType *t; + t = Copy(Active_typedef); add_pointers(t,$2.is_pointer); - DataType_typedef_add(t,$2.id,0); + SwigType_typedef(t,$2.id); lang->add_typedef(t,$2.id); cplus_register_type($2.id); - DelDataType(t); + Delete(t); } } | COMMA declaration array { - DataType *t; - t = CopyDataType(Active_typedef); - t->_status = STAT_READONLY | STAT_REPLACETYPE; - add_pointers(t, $2.is_pointer + 1); - DataType_set_arraystr(t,Char(ArrayString)); - DataType_typedef_add(t,$2.id,0); + SwigType *t; + t = Copy(Active_typedef); + add_pointers(t, $2.is_pointer); + SwigType_push(t,ArrayString); + SwigType_typedef(t,$2.id); lang->add_typedef(t,$2.id); cplus_register_type($2.id); - DelDataType(t); + Delete(t); Printf(stderr,"%s : Line %d. Warning. Array type %s will be read-only without a typemap.\n",input_file,line_number, $2.id); } | empty { } @@ -1376,36 +1366,30 @@ pragma : PRAGMA LPAREN ID COMMA ID stylearg RPAREN { stail : SEMI { } | COMMA declaration array2 def_args { init_language(); - temp_typeptr = CopyDataType(Active_type); + temp_typeptr = Copy(Active_type); add_pointers(temp_typeptr, $2.is_pointer); if ($3 > 0) { - DataType_add_pointer(temp_typeptr); - temp_typeptr->_status = STAT_READONLY; - DataType_set_arraystr(temp_typeptr,Char(ArrayString)); + SwigType_push(temp_typeptr, ArrayString); } if ($2.is_reference) { Printf(stderr,"%s : Line %d. Error. Linkage to C++ reference not allowed.\n", input_file, line_number); FatalError(); } else { - if (DataType_qualifier(temp_typeptr)) { - if ((strcmp(DataType_qualifier(temp_typeptr),"const") == 0)) { - /* Okay. This is really some sort of C++ constant here. */ - if ($4.type != T_ERROR) - create_constant($2.id, temp_typeptr, $4.id); - } else - create_variable(Active_extern,$2.id, temp_typeptr); - } else - create_variable(Active_extern, $2.id, temp_typeptr); + if (SwigType_isconst(temp_typeptr)) { + create_constant($2.id, temp_typeptr, $4.id); + } else { + create_variable(Active_extern,$2.id, temp_typeptr); + } } - DelDataType(temp_typeptr); + Delete(temp_typeptr); } stail { } | COMMA declaration LPAREN parms RPAREN cpp_const { init_language(); - temp_typeptr = CopyDataType(Active_type); + temp_typeptr = Copy(Active_type); add_pointers(temp_typeptr, $2.is_pointer); - if ($2.is_reference) DataType_add_reference(temp_typeptr); + if ($2.is_reference) SwigType_add_reference(temp_typeptr); create_function(Active_extern, $2.id, temp_typeptr, $4); - DelDataType(temp_typeptr); + Delete(temp_typeptr); Delete($4); } stail { } ; @@ -1434,8 +1418,8 @@ func_end : cpp_const LBRACE { skip_brace(); } ------------------------------------------------------------------------------ */ parms : parm ptail { - DataType *pt = Gettype($1); - if (DataType_type(pt) != T_VOID) { + SwigType *pt = Gettype($1); + if (SwigType_type(pt) != T_VOID) { Setnext($1,$2); $$ = $1; } else { @@ -1454,19 +1438,16 @@ ptail : COMMA parm ptail { parm : parm_type { $$ = $1; - if (typemap_check((char *)"ignore",typemap_lang,Gettype($$),Getname($$))) - Setignore($$,1); } parm_type : type pname { if (InArray) { - DataType_add_pointer($1); // Add array string to the type - DataType_set_arraystr($1, Char(ArrayString)); + SwigType_push($1, ArrayString); } $$ = NewParm($1,$2); Setvalue($$,DefArg); - DelDataType($1); + Delete($1); free($2); } @@ -1475,45 +1456,40 @@ parm_type : type pname { add_pointers(Gettype($$), $2); Setvalue($$,DefArg); if (InArray) { - DataType_add_pointer(Gettype($$)); // Add array string to the type - DataType_set_arraystr(Gettype($$), Char(ArrayString)); + SwigType_push(Gettype($$), ArrayString); } - DelDataType($1); + Delete($1); free($3); } | type AND pname { $$ = NewParm($1,$3); - DataType *pt = Gettype($$); - DataType_add_reference(pt); - DataType_add_pointer(pt); + SwigType *pt = Gettype($$); + SwigType_add_reference(pt); Setvalue($$,DefArg); if (!CPlusPlus) { Printf(stderr,"%s : Line %d. Warning. Use of C++ Reference detected. Use the -c++ option.\n", input_file, line_number); } - DelDataType($1); + Delete($1); free($3); } | type LPAREN stars pname RPAREN LPAREN parms RPAREN { - Printf(stderr,"%s : Line %d. Error. Function pointer not allowed (remap with typedef).\n", input_file, line_number); FatalError(); $$ = NewParm($1,$4); - DataType *pt = Gettype($$); - DataType_Settypecode(pt,T_ERROR); + SwigType *pt = Gettype($$); + DOHList *l = typelist($7); + SwigType_add_function(pt,l); + add_pointers(pt,$3); Setname($$,$4); - DataType_Setname(pt,""); - DelDataType($1); + Delete($1); free($4); Delete($7); + Delete(l); } | PERIOD PERIOD PERIOD { Printf(stderr,"%s : Line %d. Variable length arguments not supported (ignored).\n", input_file, line_number); - $$ = NewParm(NewDataType(T_INT),(char *) "varargs"); - DataType *pt = Gettype($$); - DataType_Settypecode(pt,T_ERROR); - Setname($$,(char*)"varargs"); - DataType_Setname(pt,""); + $$ = NewParm(NewSwigType(T_INT),(char *) "varargs"); FatalError(); } ; @@ -1589,20 +1565,19 @@ stars : STAR empty { $$ = 1; } array : LBRACKET RBRACKET array2 { $$ = $3 + 1; - Insert(ArrayString,0,"[]"); + SwigType_add_array(ArrayString,""); } | LBRACKET expr RBRACKET array2 { $$ = $4 + 1; - Insert(ArrayString,0,"]"); - Insert(ArrayString,0,$2.id); - Insert(ArrayString,0,"["); + SwigType_add_array(ArrayString,$2.id); } ; array2 : array { $$ = $1; } - | empty { $$ = 0; - Clear(ArrayString); + | empty { + $$ = 0; + Clear(ArrayString); } ; @@ -1643,64 +1618,34 @@ type : TYPE_INT { } | TYPE_TYPEDEF objc_protolist { $$ = $1; - if (strlen($2) > 0) { - if ((strlen($2) + strlen(DataType_Getname($$))) >= MAX_NAME) { - Printf(stderr,"%s : Line %d. Fatal error. Type-name is too long!\n", - input_file, line_number); - } else { - char temp[256]; - sprintf(temp,"%s%s",DataType_Getname($$),$2); - DataType_Setname($$,temp); - } - } + $$ = NewStringf("%s%s",$1,$2); + Delete($1); } | ID objc_protolist { - $$ = NewDataType(T_USER); - DataType_Setname($$,$1); - /* Do a typedef lookup */ - DataType_typedef_resolve($$,0); - if (strlen($2) > 0) { - if ((strlen($2) + strlen(DataType_Getname($$))) >= MAX_NAME) { - Printf(stderr,"%s : Line %d. Fatal error. Type-name is too long!\n", - input_file, line_number); - } else { - char temp[256]; - sprintf(temp,"%s%s",DataType_Getname($$),$2); - DataType_Setname($$,temp); - } - } + $$ = NewStringf("%s%s",$1,$2); + free($1); } | CONST type { $$ = $2; - DataType_set_qualifier($$,(char*)"const"); + SwigType_add_qualifier($$,"const"); } | cpptype ID { - char temp[256]; - $$ = NewDataType(T_USER); - sprintf(temp,"%s %s", $1, $2); - DataType_Setname($$,temp); + $$ = NewStringf("%s %s",$1,$2); } | ID DCOLON ID { - char temp[256]; - $$ = NewDataType(T_USER); - sprintf(temp,"%s::%s",$1,$3); - DataType_Setname($$,temp); - DataType_typedef_resolve($$,0); + $$ = NewStringf("%s::%s", $1,$3); } /* This declaration causes a shift-reduce conflict. Unresolved for now */ | DCOLON ID { - $$ = NewDataType(T_USER); - DataType_Setname($$,$2); - DataType_typedef_resolve($$,1); + $$ = NewString($2); } | ENUM ID { - char temp[256]; - $$ = NewDataType(T_INT); - sprintf(temp,"enum %s", $2); - DataType_Setname($$,temp); - DataType_typedef_resolve($$,1); + $$ = NewStringf("enum %s", $2); + } + | TYPE_RAW { + $$ = $1; } ; @@ -1739,80 +1684,55 @@ strict_type : TYPE_INT { else $$ = $1; } | TYPE_TYPEDEF objc_protolist { - $$ = $1; - strcat(DataType_Getname($$),$2); + $$ = NewStringf("%s%s", $1,$2); } | CONST type { $$ = $2; - DataType_set_qualifier($$,(char*)"const"); + SwigType_add_qualifier($$,"const"); } | cpptype ID { - char temp[256]; - $$ = NewDataType(T_USER); - sprintf(temp,"%s %s",$1, $2); - DataType_Setname($$,temp); + $$ = NewStringf("%s %s", $1, $2); + } + | TYPE_RAW { + $$ = $1; } ; /* Optional signed types */ opt_signed : empty { - $$ = (DataType *) 0; + $$ = 0; } | TYPE_INT { $$ = $1; - DataType_Settypecode($$,T_INT); - sprintf(temp_name,"signed %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); } | TYPE_SHORT opt_int { $$ = $1; - DataType_Settypecode($$,T_SHORT); - sprintf(temp_name,"signed %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); } | TYPE_LONG opt_int { $$ = $1; - DataType_Settypecode($$,T_LONG); - sprintf(temp_name,"signed %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); } | TYPE_CHAR { - $$ = $1; - DataType_Settypecode($$,T_SCHAR); - sprintf(temp_name,"signed %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); + $$ = NewString("signed char"); } ; /* Optional unsigned types */ opt_unsigned : empty { - $$ = (DataType *) 0; + $$ = 0; } | TYPE_INT { - $$ = $1; - DataType_Settypecode($$,T_UINT); - sprintf(temp_name,"unsigned %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); + $$ = NewString("unsigned int"); } | TYPE_SHORT opt_int { - $$ = $1; - DataType_Settypecode($$,T_USHORT); - sprintf(temp_name,"unsigned %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); + $$ = NewString("unsigned short"); } | TYPE_LONG opt_int { - $$ = $1; - DataType_Settypecode($$,T_ULONG); - sprintf(temp_name,"unsigned %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); + $$ = NewString("unsigned long"); } | TYPE_CHAR { - $$ = $1; - DataType_Settypecode($$,T_UCHAR); - sprintf(temp_name,"unsigned %s",DataType_Getname($1)); - DataType_Setname($$,temp_name); + $$ = NewString("unsigned char"); } ; @@ -1874,19 +1794,19 @@ enumlist : enumlist COMMA edecl {} edecl : ID { - temp_typeptr = NewDataType(T_INT); + temp_typeptr = NewSwigType(T_INT); create_constant($1, temp_typeptr, $1); - DelDataType(temp_typeptr); + Delete(temp_typeptr); } | ID EQUAL { scanner_check_typedef();} etype { - temp_typeptr = NewDataType($4.type); + temp_typeptr = NewSwigType($4.type); // Use enum name instead of value // OLD create_constant($1, temp_typeptr, $4.id); if ($4.type == T_CHAR) create_constant($1,temp_typeptr, $4.id); else create_constant($1, temp_typeptr, $1); - DelDataType(temp_typeptr); + Delete(temp_typeptr); scanner_ignore_typedef(); } | empty { } @@ -1936,14 +1856,14 @@ expr : NUM_INT { $$.type = T_ULONG; } | SIZEOF LPAREN type RPAREN { - $$.id = (char *) malloc(strlen(DataType_Getname($3))+9); - sprintf($$.id,"sizeof(%s)", DataType_Getname($3)); + $$.id = (char *) malloc(Len($3)+9); + sprintf($$.id,"sizeof(%s)", Char($3)); $$.type = T_INT; } | LPAREN strict_type RPAREN expr %prec UMINUS { - $$.id = (char *) malloc(strlen($4.id)+strlen(DataType_Getname($2))+3); - sprintf($$.id,"(%s)%s",DataType_Getname($2),$4.id); - $$.type = DataType_Gettypecode($2); + $$.id = (char *) malloc(strlen($4.id)+Len($2)+3); + sprintf($$.id,"(%s)%s",Char($2),$4.id); + $$.type = SwigType_type($2); } | ID { $$.id = $1; @@ -2079,7 +1999,7 @@ cpp_class : extern cpptype ID inherit LBRACE { char *iname; init_language(); - DataType_new_scope(0); + SwigType_new_scope(); sprintf(temp_name,"CPP_CLASS:%s\n",$3); if (add_symbol(temp_name)) { @@ -2124,7 +2044,9 @@ cpp_class : dump_nested($3); // Save and collapse current scope - cplus_register_scope(DataType_collapse_scope($3)); + SwigType_set_scope_name($3); + cplus_register_scope(SwigType_pop_scope()); + cplus_class_close((char *) 0); cplus_mode = CPLUS_PUBLIC; } @@ -2134,7 +2056,7 @@ cpp_class : | TYPEDEF cpptype ID inherit LBRACE { char *iname; init_language(); - DataType_new_scope(0); + SwigType_new_scope(); sprintf(temp_name,"CPP_CLASS:%s\n",$3); if (add_symbol(temp_name)) { @@ -2169,11 +2091,7 @@ cpp_class : } } // Create a datatype for correctly processing the typedef - Active_typedef = NewDataType(T_USER); - char temp[256]; - sprintf(temp,"%s %s", $2,$3); - DataType_Setname(Active_typedef,temp); - + Active_typedef = NewStringf("%s %s", $2, $3); // Clean up the inheritance list if ($4.names) { int j; @@ -2196,7 +2114,8 @@ cpp_class : // Collapse any datatypes created in the the class - cplus_register_scope(DataType_collapse_scope($3)); + SwigType_set_scope_name($3); + cplus_register_scope(SwigType_pop_scope()); if ($9.is_pointer > 0) { cplus_class_close($3); } else { @@ -2204,15 +2123,15 @@ cpp_class : } // Create a typedef in global scope if ($9.is_pointer == 0) { - DataType_typedef_add(Active_typedef,$9.id,0); + SwigType_typedef(Active_typedef,$9.id); lang->add_typedef(Active_typedef,$9.id); } else { - DataType *t = CopyDataType(Active_typedef); + SwigType *t = Copy(Active_typedef); add_pointers(t,$9.is_pointer); - DataType_typedef_add(t,$9.id,0); + SwigType_typedef(t,$9.id); lang->add_typedef(t,$9.id); cplus_register_type($9.id); - DelDataType(t); + Delete(t); } cplus_mode = CPLUS_PUBLIC; } typedeflist { }; @@ -2222,7 +2141,7 @@ cpp_class : | TYPEDEF cpptype LBRACE { char *iname; init_language(); - DataType_new_scope(0); + SwigType_new_scope(); if ((!CPlusPlus) && (strcmp($2,"class") == 0)) Printf(stderr,"%s : Line %d. *** WARNING ***. C++ mode is disabled (enable using -c++)\n", input_file, line_number); @@ -2249,8 +2168,7 @@ cpp_class : } } // Create a datatype for correctly processing the typedef - Active_typedef = NewDataType(T_USER); - DataType_Setname(Active_typedef,$7.id); + Active_typedef = NewString($7.id); // Dump nested classes if ($7.is_pointer == 0) @@ -2258,7 +2176,7 @@ cpp_class : // Go back to previous scope - cplus_register_scope(DataType_collapse_scope((char *) 0)); + cplus_register_scope(SwigType_pop_scope()); if ($7.is_pointer == 0) cplus_class_close($7.id); cplus_mode = CPLUS_PUBLIC; @@ -2282,7 +2200,7 @@ cpp_other :/* A dummy class name */ Printf(stderr,"%s : Line %d. *** WARNING ***. C++ mode is disabled (enable using -c++)\n", input_file, line_number); add_pointers($2,$3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); // Fix up the function name sprintf(temp_name,"%s::%s",$3.id,$5); if (!Rename_true) { @@ -2290,7 +2208,7 @@ cpp_other :/* A dummy class name */ sprintf(yy_rename,"%s_%s",$3.id,$5); } create_function($1, temp_name, $2, $7); - DelDataType($2); + Delete($2); Delete($7); } @@ -2308,7 +2226,7 @@ cpp_other :/* A dummy class name */ sprintf(yy_rename,"%s_%s",$3.id,$5); } create_variable($1,temp_name, $2); - DelDataType($2); + Delete($2); } /* Operator overloading catch */ @@ -2316,7 +2234,7 @@ cpp_other :/* A dummy class name */ | extern type declaration DCOLON OPERATOR { Printf(stderr,"%s : Line %d. Operator overloading not supported (ignored).\n", input_file, line_number); skip_decl(); - DelDataType($2); + Delete($2); } @@ -2370,13 +2288,13 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { init_language(); if (cplus_mode == CPLUS_PUBLIC) { add_pointers($1,$2.is_pointer); - if ($2.is_reference) DataType_add_reference($1); + if ($2.is_reference) SwigType_add_reference($1); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_member_func($2.id, iname, $1,$4,0); } scanner_clear_start(); - DelDataType($1); + Delete($1); Delete($4); } @@ -2387,13 +2305,13 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { init_language(); if (cplus_mode == CPLUS_PUBLIC) { add_pointers($2,$3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); iname = make_name($3.id); if (iname == $3.id) iname = 0; cplus_member_func($3.id,iname,$2,$5,1); } scanner_clear_start(); - DelDataType($2); + Delete($2); Delete($5); } @@ -2443,70 +2361,39 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { char *iname; init_language(); if (cplus_mode == CPLUS_PUBLIC) { - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($1); + if (Active_type) Delete(Active_type); + Active_type = Copy($1); add_pointers($1,$2.is_pointer); - if ($2.is_reference) DataType_add_reference($1); - if (DataType_qualifier($1)) { - if ((strcmp(DataType_qualifier($1),"const") == 0) && (DataType_is_pointer($1) == 0)) { - // Okay. This is really some sort of C++ constant here. - if ($3.type != T_ERROR) { - iname = make_name($2.id); - if (iname == $2.id) iname = 0; - cplus_declare_const($2.id,iname, $1, $3.id); - } - } else { - int oldstatus = Status; - char *tm; - if ($1->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,$1,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } + if ($2.is_reference) SwigType_add_reference($1); + if (SwigType_isconst($1)) { + iname = make_name($2.id); + if (iname == $2.id) iname = 0; + cplus_declare_const($2.id,iname, $1, $3.id); + } else { iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,$1); - Status = oldstatus; - } - } else { - char *tm = 0; - int oldstatus = Status; - if ($1->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,$1,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } - iname = make_name($2.id); - if (iname == $2.id) iname = 0; - cplus_variable($2.id,iname,$1); - Status = oldstatus; } } scanner_clear_start(); - DelDataType($1); + Delete($1); } cpp_tail { } | type declaration array def_args { char *iname; - int oldstatus = Status; - char *tm = 0; init_language(); if (cplus_mode == CPLUS_PUBLIC) { - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($1); + if (Active_type) Delete(Active_type); + Active_type = Copy($1); add_pointers($1, $2.is_pointer + 1); - if ($2.is_reference) DataType_add_reference($1); - DataType_set_arraystr($1,Char(ArrayString)); - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,$1,$2.id,(char*)"",(char*)""))) - Status = STAT_READONLY; - + if ($2.is_reference) SwigType_add_reference($1); + SwigType_push($1,ArrayString); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,$1); - Status = oldstatus; - if (!tm) - Printf(stderr,"%s : Line %d. Warning. Array member will be read-only.\n",input_file,line_number); } scanner_clear_start(); - DelDataType($1); + Delete($1); } @@ -2520,11 +2407,11 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { iname = make_name($3.id); if (iname == $3.id) iname = 0; cplus_static_var($3.id,iname,$2); - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($2); + if (Active_type) Delete(Active_type); + Active_type = Copy($2); } scanner_clear_start(); - DelDataType($2); + Delete($2); } cpp_tail { } /* Static member function */ @@ -2532,14 +2419,14 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { | STATIC type declaration LPAREN parms RPAREN cpp_end { char *iname; add_pointers($2,$3.is_pointer); - if ($3.is_reference) DataType_add_reference($2); + if ($3.is_reference) SwigType_add_reference($2); if (cplus_mode == CPLUS_PUBLIC) { iname = make_name($3.id); if (iname == $3.id) iname = 0; cplus_static_func($3.id, iname, $2, $5); } scanner_clear_start(); - DelDataType($2); + Delete($2); Delete($5); } /* Turn on public: mode */ @@ -2585,9 +2472,9 @@ cpp_member : type declaration LPAREN parms RPAREN cpp_end { if (cplus_mode == CPLUS_PUBLIC) { if ($2) { cplus_register_type($2); - if (temp_type) DelDataType(temp_type); - temp_type = NewDataType(T_INT); - DataType_typedef_add(temp_type,$2,1); + if (temp_type) Delete(temp_type); + temp_type = NewSwigType(T_INT); + SwigType_typedef(temp_type,$2); lang->add_typedef(temp_type,$2); } } @@ -2666,9 +2553,9 @@ cpp_pragma : PRAGMA ID stylearg { Char(CCode), " $classname_", $5.id, ";\n", 0); n->name = Swig_copy_string($5.id); n->line = start_line; - n->type = NewDataType(T_USER); + n->type = NewString(""); add_pointers(n->type, $5.is_pointer); - if ($5.is_reference) DataType_add_reference(n->type); + if ($5.is_reference) SwigType_add_reference(n->type); n->next = 0; add_nested(n); } @@ -2691,9 +2578,9 @@ cpp_pragma : PRAGMA ID stylearg { Char(CCode), " $classname_", $4.id, ";\n",0); n->name = Swig_copy_string($4.id); n->line = start_line; - n->type = NewDataType(T_USER); + n->type = NewString(""); add_pointers(n->type, $4.is_pointer); - if ($4.is_reference) DataType_add_reference(n->type); + if ($4.is_reference) SwigType_add_reference(n->type); n->next = 0; add_nested(n); @@ -2738,39 +2625,22 @@ type_extra : stars {} cpp_tail : SEMI { } | COMMA declaration def_args { - int oldstatus = Status; - char *tm; - init_language(); if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = CopyDataType(Active_type); + temp_typeptr = Copy(Active_type); add_pointers(temp_typeptr, $2.is_pointer); - if (temp_typeptr->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,temp_typeptr,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } cplus_variable($2.id,(char *) 0,temp_typeptr); - Status = oldstatus; - DelDataType(temp_typeptr); + Delete(temp_typeptr); } scanner_clear_start(); } cpp_tail { } | COMMA declaration array def_args { - int oldstatus = Status; - char *tm; - init_language(); if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = CopyDataType(Active_type); + temp_typeptr = Copy(Active_type); add_pointers(temp_typeptr, $2.is_pointer); - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,temp_typeptr,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - if (temp_typeptr->_status & STAT_READONLY) Status = Status | STAT_READONLY; cplus_variable($2.id,(char *) 0,temp_typeptr); - Status = oldstatus; - if (!tm) - Printf(stderr,"%s : Line %d. Warning. Array member will be read-only.\n",input_file,line_number); - DelDataType(temp_typeptr); + Delete(temp_typeptr); } scanner_clear_start(); } cpp_tail { } @@ -2793,35 +2663,34 @@ cpp_enumlist : cpp_enumlist COMMA cpp_edecl {} cpp_edecl : ID { if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = NewDataType(T_INT); + temp_typeptr = NewSwigType(T_INT); cplus_declare_const($1, (char *) 0, temp_typeptr, (char *) 0); - DelDataType(temp_typeptr); + Delete(temp_typeptr); scanner_clear_start(); } } | ID EQUAL etype { if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = NewDataType(T_INT); + temp_typeptr = NewSwigType(T_INT); cplus_declare_const($1,(char *) 0, temp_typeptr,(char *) 0); // OLD : Bug with value cplus_declare_const($1,(char *) 0, temp_typeptr,$3.id); - DelDataType(temp_typeptr); + Delete(temp_typeptr); scanner_clear_start(); } } | NAME LPAREN ID RPAREN ID { if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = NewDataType(T_INT); + temp_typeptr = NewSwigType(T_INT); cplus_declare_const($5, $3, temp_typeptr, (char *) 0); - DelDataType(temp_typeptr); + Delete(temp_typeptr); scanner_clear_start(); } } | NAME LPAREN ID RPAREN ID EQUAL etype { if (cplus_mode == CPLUS_PUBLIC) { - temp_typeptr = NewDataType(T_INT); + temp_typeptr = NewSwigType(T_INT); cplus_declare_const($5,$3, temp_typeptr, (char *) 0); -// Old : bug with value cplus_declare_const($5,$3, temp_typeptr,$7.id); - DelDataType(temp_typeptr); + Delete(temp_typeptr); scanner_clear_start(); } } @@ -3047,44 +2916,35 @@ objc_vars : objc_var objc_vartail SEMI { objc_var : type declaration { if (cplus_mode == CPLUS_PUBLIC) { int oldstatus = Status; - char *tm; char *iname; - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($1); + if (Active_type) Delete(Active_type); + Active_type = Copy($1); add_pointers($1,$2.is_pointer); - if ($2.is_reference) DataType_add_reference($1); - if ($1->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,$1,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } + if ($2.is_reference) SwigType_add_reference($1); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,$1); Status = oldstatus; } scanner_clear_start(); - DelDataType($1); + Delete($1); } | type declaration array { if (cplus_mode == CPLUS_PUBLIC) { int oldstatus = Status; - char *tm, *iname; - if (Active_type) DelDataType(Active_type); - Active_type = CopyDataType($1); + char *iname; + if (Active_type) Delete(Active_type); + Active_type = Copy($1); add_pointers($1,$2.is_pointer); - if ($2.is_reference) DataType_add_reference($1); - DataType_set_arraystr($1, Char(ArrayString)); - if ($1->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,$1,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } + if ($2.is_reference) SwigType_add_reference($1); + SwigType_push($1,ArrayString); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,$1); Status = oldstatus; } scanner_clear_start(); - DelDataType($1); + Delete($1); } | NAME LPAREN ID RPAREN { strcpy(yy_rename,$3); @@ -3094,19 +2954,15 @@ objc_var : type declaration { objc_vartail : COMMA declaration objc_vartail { if (cplus_mode == CPLUS_PUBLIC) { int oldstatus = Status; - char *tm, *iname; - DataType *t = CopyDataType (Active_type); + char *iname; + SwigType *t = Copy(Active_type); add_pointers(t,$2.is_pointer); - if ($2.is_reference) DataType_add_reference(t); - if (t->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,t,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } + if ($2.is_reference) SwigType_add_reference(t); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,t); Status = oldstatus; - DelDataType(t); + Delete(t); } scanner_clear_start(); } @@ -3114,20 +2970,15 @@ objc_vartail : COMMA declaration objc_vartail { char *iname; if (cplus_mode == CPLUS_PUBLIC) { int oldstatus = Status; - char *tm; - DataType *t = CopyDataType (Active_type); + SwigType *t = Copy(Active_type); add_pointers(t,$2.is_pointer); - if ($2.is_reference) DataType_add_reference(t); - DataType_set_arraystr(t,Char(ArrayString)); - if (t->_status & STAT_READONLY) { - if (!(tm = typemap_lookup((char*)"memberin",typemap_lang,t,$2.id,(char*)"",(char*)""))) - Status = Status | STAT_READONLY; - } + if ($2.is_reference) SwigType_add_reference(t); + SwigType_push(t,ArrayString); iname = make_name($2.id); if (iname == $2.id) iname = 0; cplus_variable($2.id,iname,t); Status = oldstatus; - DelDataType(t); + Delete(t); } scanner_clear_start(); } @@ -3174,7 +3025,7 @@ objc_method : MINUS objc_ret_type ID objc_args objc_end { if (iname == $3) iname = 0; cplus_member_func($3,iname,$2,$4,0); scanner_clear_start(); - DelDataType($2); + Delete($2); free($3); Delete($4); } @@ -3192,7 +3043,7 @@ objc_method : MINUS objc_ret_type ID objc_args objc_end { cplus_static_func($3,iname,$2,$4); } scanner_clear_start(); - DelDataType($2); + Delete($2); free($3); Delete($4); } @@ -3210,22 +3061,16 @@ objc_ret_type : LPAREN type RPAREN { add_pointers($$,$3); } | empty { /* Empty type means "id" type */ - $$ = NewDataType(T_VOID); - DataType_Setname($$,"id"); - DataType_add_pointer($$); - $$->_implicit_ptr = 1; + $$ = NewString("id"); } ; objc_arg_type : LPAREN parm RPAREN { - $$ = CopyDataType(Gettype($2)); + $$ = Copy(Gettype($2)); Delete($2); } | empty { - $$ = NewDataType(T_VOID); - DataType_Setname($$,"id"); - DataType_add_pointer($$); - $$->_implicit_ptr = 1; + $$ = NewString("id"); } ; @@ -3325,41 +3170,39 @@ tm_tail : COMMA typemap_parm tm_tail { typemap_parm : type typemap_name { if (InArray) { - DataType_add_pointer($1); - DataType_set_arraystr($1,Char(ArrayString)); + SwigType_push($1,ArrayString); } $$ = NewTMParm(); $$->p = NewParm($1,$2); $$->args = tm_parm; - DelDataType($1); + Delete($1); free($2); } | type stars typemap_name { $$ = NewTMParm(); $$->p = NewParm($1,$3); - DataType *pt = Gettype($$->p); - pt->_is_pointer += $2; + SwigType *pt = Gettype($$->p); + add_pointers(pt,$2); if (InArray) { - DataType_add_pointer(pt); - DataType_set_arraystr(pt,Char(ArrayString)); - } + SwigType_push(pt,ArrayString); + } $$->args = tm_parm; - DelDataType($1); + Delete($1); free($3); } | type AND typemap_name { $$ = NewTMParm(); $$->p = NewParm($1,$3); - DataType *pt = Gettype($$->p); - DataType_add_reference(pt); - DataType_add_pointer(pt); + SwigType *pt = Gettype($$->p); + SwigType_add_reference(pt); + SwigType_add_pointer(pt); if (!CPlusPlus) { Printf(stderr,"%s : Line %d. Warning. Use of C++ Reference detected. Use the -c++ option.\n", input_file, line_number); } $$->args = tm_parm; - DelDataType($1); + Delete($1); free($3); } | type LPAREN stars typemap_name RPAREN LPAREN parms RPAREN { @@ -3367,12 +3210,12 @@ typemap_parm : type typemap_name { FatalError(); $$ = NewTMParm(); $$->p = NewParm($1,$4); - DataType *pt = Gettype($$->p); - DataType_Settypecode(pt,T_ERROR); - Setname($$->p,$4); - DataType_Setname(pt,""); + SwigType *pt = Gettype($$->p); + DOHList *l = typelist($7); + SwigType_add_function(pt,l); + add_pointers(pt,$3); $$->args = tm_parm; - DelDataType($1); + Delete($1); free($4); Delete($7); } diff --git a/Source/SWIG1.1/scanner.cxx b/Source/SWIG1.1/scanner.cxx index 4e55591ea..1280af601 100644 --- a/Source/SWIG1.1/scanner.cxx +++ b/Source/SWIG1.1/scanner.cxx @@ -42,8 +42,6 @@ static DOHString *header = 0; static DOHString *comment = 0; DOHString *CCode = 0; // String containing C code static char *yybuffer = 0; -static int lex_pos = 0; -static int lex_len = 0; static char yytext[YYBSIZE]; static int yylen = 0; @@ -425,6 +423,10 @@ int yylook(void) { else if (c == '0') state = 83; // An octal or hex value else if (c == '\'') state = 9; // A character constant else if (c == '.') state = 100; // Maybe a number, maybe just a period + else if (c == '`') { + state = 200; // Back-tick type + yylen = 0; + } else if (isdigit(c)) state = 8; // A numerical value else if ((isalpha(c)) || (c == '_') || (c == '$')) state = 7; else state = 99; @@ -779,6 +781,15 @@ int yylook(void) { return(PERIOD); } break; + case 200: + if ((c = nextchar()) == 0) return (0); + if (c == '`') { + yytext[yylen-1] = 0; + yylval.type = NewString(yytext); + return(TYPE_RAW); + } + break; + default: if (!Error) { Printf(stderr,"%s : Line %d ::Illegal character '%c'=%d.\n",input_file, line_number,c,c); @@ -838,45 +849,43 @@ extern "C" int yylex(void) { /* Look for keywords now */ if (strcmp(yytext,"int") == 0) { - yylval.type = NewDataType(T_INT); + yylval.type = NewSwigType(T_INT); return(TYPE_INT); } if (strcmp(yytext,"double") == 0) { - yylval.type = NewDataType(T_DOUBLE); + yylval.type = NewSwigType(T_DOUBLE); return(TYPE_DOUBLE); } if (strcmp(yytext,"void") == 0) { - yylval.type = NewDataType(T_VOID); + yylval.type = NewSwigType(T_VOID); return(TYPE_VOID); } if (strcmp(yytext,"char") == 0) { - yylval.type = NewDataType(T_CHAR); + yylval.type = NewSwigType(T_CHAR); return(TYPE_CHAR); } if (strcmp(yytext,"short") == 0) { - yylval.type = NewDataType(T_SHORT); + yylval.type = NewSwigType(T_SHORT); return(TYPE_SHORT); } if (strcmp(yytext,"long") == 0) { - yylval.type = NewDataType(T_LONG); + yylval.type = NewSwigType(T_LONG); return(TYPE_LONG); } if (strcmp(yytext,"float") == 0) { - yylval.type = NewDataType(T_FLOAT); + yylval.type = NewSwigType(T_FLOAT); return(TYPE_FLOAT); } if (strcmp(yytext,"signed") == 0) { - yylval.type = NewDataType(T_INT); - DataType_Setname(yylval.type,yytext); + yylval.type = NewSwigType(T_INT); return(TYPE_SIGNED); } if (strcmp(yytext,"unsigned") == 0) { - yylval.type = NewDataType(T_UINT); - DataType_Setname(yylval.type,yytext); + yylval.type = NewSwigType(T_UINT); return(TYPE_UNSIGNED); } if (strcmp(yytext,"bool") == 0) { - yylval.type = NewDataType(T_BOOL); + yylval.type = NewSwigType(T_BOOL); return(TYPE_BOOL); } // C++ keywords @@ -993,10 +1002,8 @@ extern "C" int yylex(void) { // do a typedef lookup on it. if (check_typedef) { - if (DataType_is_typedef(yytext)) { - yylval.type = NewDataType(T_USER); - DataType_Setname(yylval.type,yytext); - DataType_typedef_resolve(yylval.type,0); + if (SwigType_istypedef(yytext)) { + yylval.type = NewString(yytext); return(TYPE_TYPEDEF); } } diff --git a/Source/SWIG1.1/swig11.h b/Source/SWIG1.1/swig11.h index 5dd22d525..03b26d3d8 100644 --- a/Source/SWIG1.1/swig11.h +++ b/Source/SWIG1.1/swig11.h @@ -149,21 +149,21 @@ struct Pragma { * Open a new C++ class definition. * cpp_close_class(char *) * Close current C++ class - * cpp_member_func(char *name, char *rname, DataType *rt, ParmList *l) + * 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, DataType *t) + * 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, DataType *t, ParmList *l) + * cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l) * A C++ static member function. - * cpp_static_var(char *name, char *iname, DataType *t) + * cpp_static_var(char *name, char *iname, SwigType *t) * A C++ static member data variable. * *************************************************************************/ @@ -172,16 +172,16 @@ class Language { public: virtual void parse_args(int argc, char *argv[]) = 0; virtual void parse() = 0; - virtual void create_function(char *, char *, DataType *, ParmList *) = 0; - virtual void link_variable(char *, char *, DataType *) = 0; - virtual void declare_const(char *, char *, DataType *, char *) = 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 initialize(void) = 0; virtual void headers(void) = 0; virtual void close(void) = 0; virtual void set_module(char *mod_name,char **mod_list) = 0; virtual void set_init(char *init_name); - virtual void add_native(char *name, char *iname, DataType *t, ParmList *l); - virtual void add_typedef(DataType *t, char *name); + virtual void add_native(char *name, char *iname, SwigType *t, ParmList *l); + virtual void add_typedef(SwigType *t, char *name); virtual void create_command(char *cname, char *iname); // @@ -189,17 +189,17 @@ public: // You can redefine these, or use the defaults below // - virtual void cpp_member_func(char *name, char *iname, DataType *t, ParmList *l); + virtual void cpp_member_func(char *name, char *iname, SwigType *t, ParmList *l); virtual void cpp_constructor(char *name, char *iname, ParmList *l); virtual void cpp_destructor(char *name, char *newname); virtual void cpp_open_class(char *name, char *rename, char *ctype, int strip); virtual void cpp_close_class(); virtual void cpp_cleanup(); virtual void cpp_inherit(char **baseclass, int mode = INHERIT_ALL); - virtual void cpp_variable(char *name, char *iname, DataType *t); - virtual void cpp_static_func(char *name, char *iname, DataType *t, ParmList *l); - virtual void cpp_declare_const(char *name, char *iname, DataType *type, char *value); - virtual void cpp_static_var(char *name, char *iname, DataType *t); + virtual void cpp_variable(char *name, char *iname, SwigType *t); + virtual void cpp_static_func(char *name, char *iname, SwigType *t, ParmList *l); + virtual void cpp_declare_const(char *name, char *iname, SwigType *type, char *value); + virtual void cpp_static_var(char *name, char *iname, SwigType *t); virtual void cpp_pragma(Pragma *plist); // Pragma directive @@ -218,8 +218,8 @@ public: /* Emit functions */ -extern void emit_func_call(char *, DataType *, ParmList *, FILE *); -extern void emit_set_get(char *, char *, DataType *); +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 *); @@ -227,11 +227,11 @@ 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, DataType *type, ParmList *l, + 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, DataType *type, ParmList *l, + char *mname, char *mrename, SwigType *type, ParmList *l, int mode); extern void cplus_emit_destructor(char *classname, char *classtype, char *classrename, @@ -241,10 +241,10 @@ extern void cplus_emit_constructor(char *classname, char *classtype, char *class char *name, char *iname, ParmList *l, int mode); extern void cplus_emit_variable_get(char *classname, char *classtype, char *classrename, - char *name, char *iname, DataType *type, int mode); + char *name, char *iname, SwigType *type, int mode); extern void cplus_emit_variable_set(char *classname, char *classtype, char *classrename, - char *name, char *iname, DataType *type, int mode); + char *name, char *iname, SwigType *type, int mode); extern char *cplus_base_class(char *name); @@ -264,24 +264,22 @@ extern "C" { // Misc -extern int emit_args(DataType *, ParmList *, Wrapper *f); -extern void emit_func_call(char *, DataType *, ParmList *, Wrapper *f); +extern int emit_args(SwigType *, ParmList *, Wrapper *f); +extern void emit_func_call(char *, SwigType *, ParmList *, Wrapper *f); extern void SWIG_exit(int); // ----------------------------------------------------------------------- // Typemap support // ----------------------------------------------------------------------- - -extern void typemap_register(char *op, char *lang, DataType *type, char *pname, char *code, ParmList *l = 0); -extern void typemap_register(char *op, char *lang, char *type, char *pname, char *code,ParmList *l = 0); -extern void typemap_register_default(char *op, char *lang, int type, int ptr, char *arraystr, char *code, ParmList *l = 0); -extern char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *source, char *target, - Wrapper *f = 0); -extern void typemap_clear(char *op, char *lang, DataType *type, char *pname); -extern void typemap_copy(char *op, char *lang, DataType *stype, char *sname, DataType *ttype, char *tname); -extern char *typemap_check(char *op, char *lang, DataType *type, char *pname); -extern void typemap_apply(DataType *tm_type, char *tmname, DataType *type, char *pname); -extern void typemap_clear_apply(DataType *type, char *pname); +#ifndef OLD +extern void typemap_register(char *op, char *lang, SwigType *type, String_or_char *pname, String_or_char *code, ParmList *l = 0); +extern char *typemap_lookup(char *op, char *lang, SwigType *type, String_or_char *pname, String_or_char *source, String_or_char *target, Wrapper *f = 0); +extern void typemap_clear(char *op, char *lang, SwigType *type, String_or_char *pname); +extern void typemap_copy(char *op, char *lang, SwigType *stype, String_or_char *sname, + SwigType *ttype, String_or_char *tname); +extern char *typemap_check(char *op, char *lang, SwigType *type, String_or_char *pname); +extern void typemap_apply(SwigType *tm_type, String_or_char *tmname, SwigType *type, String_or_char *pname); +extern void typemap_clear_apply(SwigType *type, String_or_char *pname); extern int check_numopt(ParmList *); @@ -289,8 +287,26 @@ extern int check_numopt(ParmList *); // Code fragment support // ----------------------------------------------------------------------- -extern void fragment_register(char *op, char *lang, char *code); -extern char *fragment_lookup(char *op, char *lang, int age); +extern void fragment_register(char *op, char *lang, String_or_char *code); +extern char *fragment_lookup(char *op, char *lang); extern void fragment_clear(char *op, char *lang); +#else + +#define typemap_register(op,lang,type,pname,code,l) +#define typemap_register_default(op,lang,type,ptr,arraystr,code,l) +#define typemap_lookup(op,lang,type,pname,source,target,f) 0 + +#define typemap_clear(op,lang,type,pname) +#define typemap_copy(op,lang,stype,sname,ttype,tname) +#define typemap_check(op,lang,type,pname) 0 +#define typemap_apply(tm,tmname,type,pname) +#define typemap_clear_apply(type,pname) +#define check_numopt(l) ParmList_len(l) +#define fragment_register(op,lang,code) +#define fragment_lookup(op,lang,age) 0 +#define fragment_clear(op,lang) + +#endif + diff --git a/Source/SWIG1.1/typemap.cxx b/Source/SWIG1.1/typemap.cxx index 0d8bc1790..c87e7be9c 100644 --- a/Source/SWIG1.1/typemap.cxx +++ b/Source/SWIG1.1/typemap.cxx @@ -65,11 +65,13 @@ extern "C" { static ParmList *last_args = 0; +int type_id = 0; + /* Structure for holding a typemap */ struct TypeMap { char *lang; - DataType *type; + SwigType *type; DOHString *code; int first; int last; @@ -77,9 +79,9 @@ struct TypeMap { TypeMap *previous; /* Previously defined typemap (if any) */ ParmList *args; /* Local variables (if any) */ - TypeMap(char *l, DataType *t, char *c, ParmList *p = 0) { + TypeMap(char *l, SwigType *t, String_or_char *c, ParmList *p = 0) { lang = Swig_copy_string(l); - type = CopyDataType(t); + type = Copy(t); code = NewString(c); first = type_id; last = INT_MAX; @@ -91,7 +93,7 @@ struct TypeMap { args = 0; } } - TypeMap(char *l, char *c) { + TypeMap(char *l, String_or_char *c) { lang = Swig_copy_string(l); type = 0; code = NewString(c); @@ -103,7 +105,7 @@ struct TypeMap { } TypeMap(TypeMap *t) { lang = Swig_copy_string(t->lang); - type = CopyDataType(t->type); + type = Copy(t->type); code = Copy(t->code); first = type_id; last = INT_MAX; @@ -124,14 +126,14 @@ static DOH *typemap_hash = 0; /* Structure for holding "applications of a typemap" */ struct TmMethod { - char *name; /* Typemap name; */ - DataType *type; /* Typemap type */ + String *name; /* Typemap name; */ + SwigType *type; /* Typemap type */ TmMethod *next; /* Next method */ - TmMethod(char *n, DataType *t, TmMethod *m = 0) { - if (n) name = Swig_copy_string(n); + TmMethod(String *n, SwigType *t, TmMethod *m = 0) { + if (n) name = Copy(n); else name = 0; if (t) { - type = CopyDataType(t); + type = Copy(t); } else { type = 0; } @@ -150,13 +152,13 @@ static DOH *application_hash = 0; * Called by the %apply directive. * ------------------------------------------------------------------------ */ -void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname) { +void typemap_apply(SwigType *tm_type, String_or_char *tm_name, SwigType *type, String_or_char *pname) { TmMethod *m,*m1; - char temp[512]; + String *temp; /* Form the application name */ - if (!pname) pname = (char*)""; - sprintf(temp,"%s$%s",DataType_str(type,0),pname); + if (!pname) pname = (String_or_char*)""; + temp = NewStringf("%s$%s",SwigType_str(type,0),pname); /* See if there is a method already defined */ @@ -168,26 +170,27 @@ void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname SetVoid(application_hash,temp,m); } + Delete(temp); + /* Check to see if an array typemap has been applied to a non-array type */ - if ((DataType_arraystr(tm_type)) && (!DataType_arraystr(type))) { + if ((SwigType_isarray(tm_type)) && (!SwigType_isarray(type))) { Printf(stderr,"%s:%d: Warning. Array typemap has been applied to a non-array type.\n", input_file,line_number); } /* If both are arrays, make sure they have the same dimension */ - if ((DataType_arraystr(tm_type)) && (DataType_arraystr(type))) { - char s[128],*t; - if (DataType_array_dimensions(tm_type) != DataType_array_dimensions(type)) { + if ((SwigType_isarray(tm_type)) && (SwigType_isarray(type))) { + if (SwigType_array_ndim(tm_type) != SwigType_array_ndim(type)) { Printf(stderr,"%s:%d: Warning. Array types have different number of dimensions.\n", input_file,line_number); } else { - for (int i = 0; i < DataType_array_dimensions(tm_type); i++) { - strcpy(s,DataType_get_dimension(tm_type,i)); - t = DataType_get_dimension(type,i); - if (strcmp(s,"ANY") != 0) { - if (strcmp(s,t)) + for (int i = 0; i < SwigType_array_ndim(tm_type); i++) { + String *s1 = SwigType_array_getdim(tm_type,i); + String *s2 = SwigType_array_getdim(type,i); + if (Cmp(s1,"") != 0) { + if (Cmp(s1,s2)) Printf(stderr,"%s:%d: Warning. Array typemap applied to an array of different size.\n", input_file, line_number); } @@ -196,49 +199,38 @@ void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname } /* Add a new mapping corresponding to the typemap */ - m1 = new TmMethod(tm_name,tm_type,m->next); m->next = m1; } /* ------------------------------------------------------------------------ - * void typemap_clear_apply(DataType *type, char *pname) + * void typemap_clear_apply(SwigType *type, char *pname) * * Clears the application of a typemap. * Called by the %clear directive. * ------------------------------------------------------------------------ */ -void typemap_clear_apply(DataType *type, char *pname) { - char temp[512]; - if (!pname) pname = (char*)""; - sprintf(temp,"%s$%s", DataType_str(type,0), pname); +void typemap_clear_apply(SwigType *type, String_or_char *pname) { + String *temp; + if (!pname) pname = (String_or_char*)""; + temp = NewStringf("%s$%s", SwigType_str(type,0), pname); if (!application_hash) application_hash = NewHash(); Delattr(application_hash,temp); + Delete(temp); } /* ------------------------------------------------------------------------ - * char *typemap_string(char *lang, DataType *type, char *pname, char *ary, char *suffix) + * char *typemap_string(char *lang, DataType *type, char *pname, char *suffix) * * Produces a character string corresponding to a lang, datatype, and * method. This string is used as the key for our typemap hash table. * ------------------------------------------------------------------------ */ -static char *typemap_string(char *lang, DataType *type, char *pname, char *ary, char *suffix) { - static DOHString *str = 0; - - int old_status; - if (!str) str = NewString(""); - old_status = type->_status; - type->_status = 0; - Clear(str); - - if (ary) - Printv(str, lang, DataType_str(type,0), pname, ary, suffix, 0); - else - Printv(str, lang, DataType_str(type,0), pname, suffix,0); - - type->_status = old_status; - return Char(str); +static String *typemap_string(char *op, char *lang, SwigType *type, String_or_char *pname) { + String *str; + str = NewStringf("%s-%s-%s",op,lang,SwigType_str(type,pname)); + /* Printf(stdout,"key: %s\n", str); */ + return Swig_temp_result(str); } /* ------------------------------------------------------------------------ @@ -248,69 +240,47 @@ static char *typemap_string(char *lang, DataType *type, char *pname, char *ary, * Register a new mapping with the type-mapper. * ------------------------------------------------------------------------ */ -void typemap_register(char *op, char *lang, DataType *type, char *pname, - char *getcode, ParmList *args) { +void typemap_register(char *op, char *lang, SwigType *type, String_or_char *pname, + String_or_char *getcode, ParmList *args) { - char *key; - TypeMap *tm,*tm_old; - char temp[256]; + String *key; + TypeMap *tm, *tm_old; int is_default = 0; - /* printf("Registering : %s %s %s %s\n%s\n", op, lang, DataType_print_type(type), pname, getcode); */ - if (!typemap_hash) typemap_hash = NewHash(); + tm = new TypeMap(lang,type,getcode,args); /* If this is a default typemap, downgrade the type! */ - if (strcmp(pname,"SWIG_DEFAULT_TYPE") == 0) { - DataType_primitive(tm->type); + if (Cmp(pname,"SWIG_DEFAULT_TYPE") == 0) { + tm->type = SwigType_default(tm->type); is_default = 1; } - key = typemap_string(lang,tm->type,pname,DataType_arraystr(tm->type), op); + key = typemap_string(op,lang,tm->type,pname); /* Get any previous setting of the typemap */ - - tm_old = (TypeMap *) GetVoid(typemap_hash,key); - + tm_old = (TypeMap *) GetVoid(typemap_hash, key); if (tm_old) { /* Perform a chaining operation, but only if the last typemap is active. */ - - if (type_id < tm_old->last) { - sprintf(temp,"$%s",op); - Replace(tm->code,temp,tm_old->code, DOH_REPLACE_ANY); - } - /* If found, we need to attach the old version to the new one */ tm->previous = tm_old; tm->next = tm_old; tm_old->last = type_id; - - /* Remove the old one from the hash */ - - Delattr(typemap_hash,key); } /* Add new typemap to the hash table */ SetVoid(typemap_hash,key,tm); - /* Now try to perform default chaining operation (if available) - * if (!is_default) { - * sprintf(temp,"$%s",op); - * if (strstr(tm->code,temp)) { - * tm->code.replace(temp,typemap_resolve_default(op,lang,type)); - * } - * } */ - /* Just a sanity check to make sure args look okay. */ if (args) { Parm *p = tm->args; while (p) { - char *pn = Getname(p); + String *pn = Getname(p); if (pn) { /* printf(" %s %s\n", pt,pn); */ } else { @@ -322,50 +292,6 @@ void typemap_register(char *op, char *lang, DataType *type, char *pname, } } -/* ------------------------------------------------------------------------ - * void typemap_register(char *op, char *lang, char *type, char *pname, - * char *getcode, ParmList *args) - * - * Register a new mapping with the type-mapper. Special version that uses a - * string instead of a datatype. - * ------------------------------------------------------------------------ */ - -void typemap_register(char *op, char *lang, char *type, char *pname, - char *getcode, ParmList *args) { - DataType *temp; - temp = NewDataType(0); - DataType_Setname(temp,type); - DataType_Settypecode(temp,T_USER); - typemap_register(op,lang,temp,pname,getcode,args); - DelDataType(temp); -} - - -/* ------------------------------------------------------------------------ - * void typemap_register_default(char *op, char *lang, int type, int ptr, char *arraystr, - * char *code, ParmList *args) - * - * Registers a default typemap with the system using numerical type codes. - * type is the numerical code, ptr is the level of indirection. - * ------------------------------------------------------------------------ */ - -void typemap_register_default(char *op, char *lang, int type, int ptr, char *arraystr, - char *code, ParmList *args) { - - DataType *t = NewDataType(type); - - /* Create a raw datatype from the arguments */ - - t->_is_pointer = ptr; - DataType_set_arraystr(t,arraystr); - - /* Now, go register this as a default type */ - - typemap_register(op,lang,t,(char*)"SWIG_DEFAULT_TYPE",code,args); - DelDataType(t); -} - - /* ------------------------------------------------------------------------ * static TypeMap *typemap_search(char *key, int id) * @@ -377,10 +303,9 @@ void typemap_register_default(char *op, char *lang, int type, int ptr, char *arr * handle scoping problems. * ------------------------------------------------------------------------ */ -TypeMap *typemap_search(char *key, int id) { - +static TypeMap * +typemap_search(String_or_char *key, int id) { TypeMap *tm; - if (!typemap_hash) typemap_hash = NewHash(); tm = (TypeMap *) GetVoid(typemap_hash,key); while (tm) { @@ -399,69 +324,64 @@ TypeMap *typemap_search(char *key, int id) { * substituted. * ------------------------------------------------------------------------ */ -TypeMap *typemap_search_array(char *op, char *lang, DataType *type, char *pname, DOHString *str) { - char origarr[1024]; - char *key; +static +TypeMap *typemap_search_array(char *op, char *lang, SwigType *type, String_or_char *pname, DOHString *str) { + SwigType *atype; + String *key; int ndim,i,j,k,n; TypeMap *tm; char temp[10]; - if (!DataType_arraystr(type)) return 0; + if (!SwigType_isarray(type)) return 0; - strcpy(origarr,DataType_arraystr(type)); /* First check to see if exactly this array has been mapped */ - key = typemap_string(lang,type,pname,DataType_arraystr(type),op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,pname); + tm = typemap_search(key,type_id); /* Check for unnamed array of specific dimensions */ if (!tm) { - key = typemap_string(lang,type,(char*)"",DataType_arraystr(type),op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,(char*)""); + tm = typemap_search(key,type_id); } if (!tm) { /* We're going to go search for matches with the ANY tag */ - DOHString *tempastr = NewString(""); - ndim = DataType_array_dimensions(type); /* Get number of dimensions */ + ndim = SwigType_array_ndim(type); /* Get number of dimensions */ j = (1 << ndim) - 1; /* Status bits */ for (i = 0; i < (1 << ndim); i++) { /* Form an array string */ - Clear(tempastr); + atype = Copy(type); k = j; for (n = 0; n < ndim; n++) { - if (k & 1) { - Printf(tempastr,"[%s]",DataType_get_dimension(type,n)); - } else { - Printf(tempastr,"[ANY]"); + if (!(k & 1)) { + SwigType_array_setdim(atype,n,"ANY"); } k = k >> 1; } - DataType_set_arraystr(type, Char(tempastr)); - key = typemap_string(lang,type,pname,DataType_arraystr(type),op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,pname); + tm = typemap_search(key,type_id); if (!tm) { - key = typemap_string(lang,type,(char*)"",DataType_arraystr(type),op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,(char*)""); + tm = typemap_search(key,type_id); } - DataType_set_arraystr(type,origarr); if (tm) { - Delete(tempastr); + Delete(atype); break; } j--; } - Delete(tempastr); + Delete(atype); } if (tm) { Printf(str,"%s",tm->code); - ndim = DataType_array_dimensions(type); + ndim = SwigType_array_ndim(type); sprintf(temp,"%d",ndim); Replace(str,"$ndim",temp, DOH_REPLACE_ANY); for (i = 0; i < ndim; i++) { sprintf(temp,"$dim%d",i); - Replace(str,temp,DataType_get_dimension(type,i), DOH_REPLACE_ANY); + Replace(str,temp,SwigType_array_getdim(type,i), DOH_REPLACE_ANY); } } return tm; @@ -476,54 +396,37 @@ TypeMap *typemap_search_array(char *op, char *lang, DataType *type, char *pname, * Substitutes locals in the string with actual values used. * ------------------------------------------------------------------------ */ -static void typemap_locals(DataType *t, char *pname, DOHString *s, ParmList *l, Wrapper *f) { +static void typemap_locals(SwigType *t, String_or_char *pname, DOHString *s, ParmList *l, Wrapper *f) { Parm *p; char *new_name; p = l; while (p) { - DataType *pt = Gettype(p); - char *pn = Getname(p); + SwigType *pt = Gettype(p); + String *pn = Getname(p); if (pn) { - if (strlen(pn) > 0) { + if (Len(pn) > 0) { DOHString *str; - DataType *tt; + SwigType *tt; str = NewString(""); /* If the user gave us $type as the name of the local variable, we'll use the passed datatype instead */ - if (strcmp(pn,"$type")==0 || strcmp(DataType_Getname(pt),"$basetype")==0) { + if (Cmp(SwigType_base(pt),"$type")==0 || Cmp(SwigType_base(pt),"$basetype")==0) { tt = t; } else { tt = pt; } - - /* Have a real parameter here */ - if (DataType_arraystr(tt)) { - DataType_del_pointer(tt); - Printf(str,"%s%s",pn, DataType_arraystr(tt)); - } - else { - Printf(str,"%s",pn); - } - + Printf(str,"%s",pn); /* Substitute parameter names */ Replace(str,"$arg",pname, DOH_REPLACE_ANY); - if (strcmp(DataType_Getname(pt),"$basetype")==0) { + if (Cmp(SwigType_base(pt),"$basetype")==0) { /* use $basetype */ - char temp_ip = tt->_is_pointer; - char temp_ip1 = tt->_implicit_ptr; - tt->_is_pointer = 0; - tt->_implicit_ptr = 0; - new_name = Wrapper_new_localv(f,str, DataType_str(tt,0), str, 0); - tt->_is_pointer = temp_ip; - tt->_implicit_ptr = temp_ip1; - } - else - new_name = Wrapper_new_localv(f,str, DataType_str(tt,str), 0); - - if (DataType_arraystr(tt)) tt->_is_pointer++; + new_name = Wrapper_new_localv(f,str,SwigType_base(tt),str,0); + } else { + new_name = Wrapper_new_localv(f,str, SwigType_str(tt,str), 0); + } /* Substitute */ Replace(s,pn,new_name,DOH_REPLACE_ID); } @@ -533,14 +436,13 @@ static void typemap_locals(DataType *t, char *pname, DOHString *s, ParmList *l, /* If the original datatype was an array. We're going to go through and substitute it's array dimensions */ - if (DataType_arraystr(t)) { + if (SwigType_isarray(t)) { char temp[10]; - for (int i = 0; i < DataType_array_dimensions(t); i++) { + for (int i = 0; i < SwigType_array_ndim(t); i++) { sprintf(temp,"$dim%d",i); - Replace(f->locals,temp,DataType_get_dimension(t,i), DOH_REPLACE_ANY); + Replace(f->locals,temp,SwigType_array_getdim(t,i), DOH_REPLACE_ANY); } } - } /* ------------------------------------------------------------------------ @@ -577,84 +479,66 @@ static void typemap_locals(DataType *t, char *pname, DOHString *s, ParmList *l, * Array dimensions are substituted into the variables $dim1, $dim2,...,$dim9 * ------------------------------------------------------------------------ */ -static DataType *realtype; /* This is a gross hack */ -static char *realname = 0; /* Real parameter name */ +static SwigType *realtype; /* This is a gross hack */ +static String *realname = 0; /* Real parameter name */ -char *typemap_lookup_internal(char *op, char *lang, DataType *type, char *pname, char *source, - char *target, Wrapper *f) { - static DOHString *str = 0; - char *key = 0; +static char *typemap_lookup_internal(char *op, char *lang, SwigType *type, String_or_char *pname, + String_or_char *source, String_or_char *target, Wrapper *f) { + String *str = 0; + String *key = 0; TypeMap *tm = 0; last_args = 0; - if (!str) str = NewString(""); if (!lang) { return 0; } - + str = NewString(""); /* First check for named array */ - Clear(str); tm = typemap_search_array(op,lang,type,pname,str); /* Check for named argument */ if (!tm) { - key = typemap_string(lang,type,pname,0,op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,pname); + tm = typemap_search(key,type_id); if (tm) Printf(str,"%s",tm->code); } /* Check for unnamed type */ if (!tm) { - key = typemap_string(lang,type,(char*)"",0,op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,(char*)""); + tm = typemap_search(key,type_id); if (tm) Printf(str,"%s", tm->code); } - if (!tm) return 0; + if (!tm) { + Delete(str); + return 0; + } /* Now perform character replacements */ Replace(str,"$source",source,DOH_REPLACE_ANY); Replace(str,"$target",target,DOH_REPLACE_ANY); - Replace(str,"$type",DataType_str(realtype,0),DOH_REPLACE_ANY); + Replace(str,"$type",SwigType_str(realtype,0),DOH_REPLACE_ANY); if (realname) { Replace(str,"$parmname",realname,DOH_REPLACE_ANY); } else { Replace(str,"$parmname","", DOH_REPLACE_ANY); } /* Print base type (without any pointers) */ - { - char temp_ip = realtype->_is_pointer; - char temp_ip1 = realtype->_implicit_ptr; - realtype->_is_pointer = 0; - realtype->_implicit_ptr = 0; - char *bt = DataType_str(realtype,0); - if (bt[strlen(bt)-1] == ' ') - bt[strlen(bt)-1] = 0; - Replace(str,"$basetype",bt,DOH_REPLACE_ANY); - Replace(str,"$basemangle",DataType_manglestr(realtype), DOH_REPLACE_ANY); - realtype->_is_pointer = temp_ip; - realtype->_implicit_ptr = temp_ip1; - } - - Replace(str,"$mangle",DataType_manglestr(realtype), DOH_REPLACE_ANY); + Replace(str,"$basetype",SwigType_base(realtype), DOH_REPLACE_ANY); + Replace(str,"$basemangle",SwigType_manglestr(SwigType_base(realtype)), DOH_REPLACE_ANY); + Replace(str,"$mangle",SwigType_manglestr(realtype), DOH_REPLACE_ANY); /* If there were locals and a wrapper function, replace */ if ((tm->args) && f) { typemap_locals(realtype, pname, str,tm->args,f); } - /* If there were locals and no wrapper function, print a warning */ - /* if ((tm->args) && !f) { - if (!pname) pname = (char*)""; - Printf(stderr,"%s:%d: Warning. '%%typemap(%s,%s) %s %s' being applied with ignored locals.\n", - input_file, line_number, lang,op, DataType_str(type,0), pname); - } - */ /* Return character string */ - last_args = tm->args; + Swig_temp_result(str); return Char(str); } @@ -662,17 +546,19 @@ char *typemap_lookup_internal(char *op, char *lang, DataType *type, char *pname, * Real function call that takes care of application mappings * ---------------------------------------------------------- */ -char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *source, - char *target, Wrapper *f) { +char *typemap_lookup(char *op, char *lang, SwigType *type, String_or_char *pname, String_or_char *source, + String_or_char *target, Wrapper *f) { TmMethod *m; - char temp[512]; char *result; - char *ppname; + String *temp; + String_or_char *ppname; char *tstr; realtype = type; /* The other half of the gross hack */ realname = pname; + // Printf(stdout,"Looking up %s\n", SwigType_str(type,pname)); + /* Try to apply typemap right away */ result = typemap_lookup_internal(op,lang,type,pname,source,target,f); @@ -680,159 +566,93 @@ char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *so /* If not found, try to pick up anything that might have been specified with %apply */ - if ((!result) && (pname)) { - int drop_pointer = 0; - ppname = pname; - if (!ppname) ppname = (char*)""; - - /* The idea : We're going to cycle through applications and - drop pointers off until we get a match. */ - - while (drop_pointer <= (type->_is_pointer - type->_implicit_ptr)) { - type->_is_pointer -= drop_pointer; - tstr = DataType_str(type,0); - sprintf(temp,"%s$%s",tstr,ppname); - /* No mapping was found. See if the name has been mapped with %apply */ + if (!result) { + temp = NewStringf("%s$%s", SwigType_str(type,0), pname); + m = (TmMethod *) GetVoid(application_hash,temp); + if (!m) { + Clear(temp); + Printf(temp,"%s$",SwigType_str(type,0)); m = (TmMethod *) GetVoid(application_hash,temp); - if (!m) { - sprintf(temp,"%s$",tstr); - m = (TmMethod *) GetVoid(application_hash,temp); - } - if (m) { - m = m->next; - while (m) { - char *oldary = 0; - static DOHString *newarray = 0; - if (!newarray) newarray = NewString(""); - if (*(m->name)) ppname = m->name; - else ppname = pname; - m->type->_is_pointer += drop_pointer; - - /* Copy old array string (just in case) */ - - if (DataType_arraystr(m->type)) - oldary = Swig_copy_string(DataType_arraystr(m->type)); - else - oldary = 0; - - /* If the mapping type is an array and has the 'ANY' keyword, we - have to play some magic */ - - if ((DataType_arraystr(m->type)) && (DataType_arraystr(type))) { - /* Build up the new array string */ - Clear(newarray); - for (int n = 0; n < DataType_array_dimensions(m->type); n++) { - char *d = DataType_get_dimension(m->type,n); - if (strcmp(d,"ANY") == 0) { - Printf(newarray,"[%s]", DataType_get_dimension(type,n)); - } else { - Printf(newarray,"[%s]", d); - } - } - DataType_set_arraystr(m->type, Char(newarray)); - } else if (DataType_arraystr(type)) { - /* If an array string is available for the current datatype, - make it available. */ - DataType_set_arraystr(m->type,DataType_arraystr(type)); - } - result = typemap_lookup_internal(op,lang,m->type,ppname,source,target,f); - DataType_set_arraystr(m->type,oldary); - if (oldary) - free(oldary); - m->type->_is_pointer -= drop_pointer; - if (result) { - type->_is_pointer += drop_pointer; - return result; - } - m = m->next; + } + Delete(temp); + if (m) { + m = m->next; + while (m) { + result = typemap_lookup_internal(op,lang,m->type,m->name,source,target,f); + if (result) { + return result; } + m = m->next; } - type->_is_pointer += drop_pointer; - drop_pointer++; } } + /* Still no idea, try to find a default typemap */ if (!result) { - DataType *t = CopyDataType(type); - DataType_primitive(t); /* Knock it down to its basic type */ + SwigType *t = SwigType_default(type); result = typemap_lookup_internal(op,lang,t,(char*)"SWIG_DEFAULT_TYPE",source,target,f); if (result) { - DelDataType(t); + Delete(t); return result; } - int tc = DataType_type(t); - if (tc == T_STRING) return 0; - if ((tc == T_USER) || (tc == T_POINTER)) { - /* Still no result, go even more primitive */ - DataType_Settypecode(t, T_USER); - t->_is_pointer = 1; - DataType_set_arraystr(t,0); - DataType_primitive(t); - result = typemap_lookup_internal(op,lang,t,(char*)"SWIG_DEFAULT_TYPE",source,target,f); - } - DelDataType(t); + Delete(t); } return result; } /* ---------------------------------------------------------------------------- - * char *typemap_check(char *op, char *lang, DataType *type, char *pname) + * char *typemap_check(char *op, char *lang, SwigType *type, String_or_char *pname) * * Checks to see if there is a typemap. Returns typemap string if found, NULL * if not. * ---------------------------------------------------------------------------- */ -char *typemap_check_internal(char *op, char *lang, DataType *type, char *pname) { - static DOHString *str = 0; - char *key = 0; +char *typemap_check_internal(char *op, char *lang, SwigType *type, String_or_char *pname) { + DOHString *str = 0; + String *key = 0; TypeMap *tm = 0; - if (!str) str = NewString(""); + if (!lang) { return 0; } + str = NewString(""); + /* First check for named array */ - Clear(str); tm = typemap_search_array(op,lang,type,pname,str); - /* First check for named array - * - * if (type->arraystr) { - * key = typemap_string(lang,type,pname,type->arraystr,op); - * tm = typemap_search(key,type->_id); - * } */ - /* Check for named argument */ if (!tm) { - key = typemap_string(lang,type,pname,0,op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,pname); + tm = typemap_search(key,type_id); } /* Check for unnamed array */ - if ((!tm) && (DataType_arraystr(type))) { - key = typemap_string(lang,type,(char*)"",DataType_arraystr(type),op); - tm = typemap_search(key,type->_id); + if ((!tm) && (SwigType_isarray(type))) { + key = typemap_string(op,lang,type,(char*)""); + tm = typemap_search(key,type_id); } - /* Check for unname type */ + /* Check for unnamed type */ if (!tm) { - key = typemap_string(lang,type,(char*)"",0,op); - tm = typemap_search(key,type->_id); + key = typemap_string(op,lang,type,(char*)""); + tm = typemap_search(key,type_id); + } + if (!tm) { + Delete(str); + return 0; } - if (!tm) return 0; - - Clear(str); Printf(str,"%s",tm->code); - /* Return character string */ + Swig_temp_result(str); return Char(str); } /** Function for checking with applications */ -char *typemap_check(char *op, char *lang, DataType *type, char *pname) { +char *typemap_check(char *op, char *lang, SwigType *type, String_or_char *pname) { TmMethod *m; char temp[512]; char *result; @@ -842,6 +662,7 @@ char *typemap_check(char *op, char *lang, DataType *type, char *pname) { result = typemap_check_internal(op,lang,type,pname); +#ifdef OLD if (!result) { int drop_pointer = 0; ppname = pname; @@ -908,27 +729,17 @@ char *typemap_check(char *op, char *lang, DataType *type, char *pname) { drop_pointer++; } } +#endif /* If still no result, might have a default typemap */ if (!result) { - DataType *t = CopyDataType(type); - DataType_primitive(t); /* Knock it down to its basic type */ + SwigType *t = SwigType_default(type); result = typemap_check_internal(op,lang,t,(char*)"SWIG_DEFAULT_TYPE"); if (result) { - DelDataType(t); + Delete(t); return result; } - int tc = DataType_type(t); - if (tc == T_STRING) return 0; - if ((tc == T_USER) || (tc == T_POINTER)) { - /* Still no result, go even more primitive */ - DataType_Settypecode(t,T_USER); - t->_is_pointer = 1; - DataType_set_arraystr(t,0); - DataType_primitive(t); - result = typemap_check_internal(op,lang,t,(char*)"SWIG_DEFAULT_TYPE"); - } - DelDataType(t); + Delete(t); } return result; } @@ -941,12 +752,12 @@ char *typemap_check(char *op, char *lang, DataType *type, char *pname) { * previous map, then don't worry about it. * ------------------------------------------------------------------------ */ -void typemap_clear(char *op, char *lang, DataType *type, char *pname) { +void typemap_clear(char *op, char *lang, SwigType *type, String_or_char *pname) { - char *key; + String *key; TypeMap *tm; - key = typemap_string(lang,type,pname,DataType_arraystr(type),op); + key = typemap_string(op,lang,type,pname); /* Look for any previous version, simply set the last id if applicable. */ @@ -965,29 +776,18 @@ void typemap_clear(char *op, char *lang, DataType *type, char *pname) { * Copies the code associate with a typemap * ------------------------------------------------------------------------ */ -void typemap_copy(char *op, char *lang, DataType *stype, char *sname, - DataType *ttype, char *tname) { +void typemap_copy(char *op, char *lang, SwigType *stype, String_or_char *sname, + SwigType *ttype, String_or_char *tname) { - char *key; + String *key; TypeMap *tm, *tk, *tn; /* Try to locate a previous typemap */ - key = typemap_string(lang,stype,sname,DataType_arraystr(stype),op); - tm = typemap_search(key,stype->_id); + key = typemap_string(op,lang,stype,sname); + tm = typemap_search(key,type_id); if (!tm) return; - if (strcmp(DataType_Getname(ttype),"PREVIOUS") == 0) { - /* Pop back up to the previous typemap (if any) */ - tk = tm->next; - if (tk) { - tn = new TypeMap(tk); /* Make a copy of the previous typemap */ - tn->next = tm; /* Set up symlinks */ - Delattr(typemap_hash,key); /* Remove old hash entry */ - SetVoid(typemap_hash,key, tn); - } - } else { - typemap_register(op,lang,ttype,tname,Char(tm->code),tm->args); - } + typemap_register(op,lang,ttype,tname,tm->code,tm->args); } /* ------------------------------------------------------------------------ @@ -1009,7 +809,7 @@ static char *fragment_string(char *op, char *lang) { * Register a code fragment with the type-mapper. * ------------------------------------------------------------------------ */ -void fragment_register(char *op, char *lang, char *code) { +void fragment_register(char *op, char *lang, String_or_char *code) { char *key; TypeMap *tm,*tm_old; @@ -1044,38 +844,35 @@ void fragment_register(char *op, char *lang, char *code) { /* Add new typemap to the hash table */ SetVoid(typemap_hash,key,tm); - } /* ------------------------------------------------------------------------ - * char *fragment_lookup(char *op, char *lang, int age) + * char *fragment_lookup(char *op, char *lang) * * op is string code for type of mapping * lang is the target language string - * age is age of fragment. * * Returns NULL if no mapping is found. * * ------------------------------------------------------------------------ */ -char *fragment_lookup(char *op, char *lang, int age) { - static DOHString *str = 0; +char *fragment_lookup(char *op, char *lang) { + DOHString *str; char *key = 0; TypeMap *tm = 0; - - if (!str) str = NewString(""); + if (!lang) { return 0; } - - Clear(str); + str = NewString(""); key = fragment_string(op,lang); - tm = typemap_search(key,age); + tm = typemap_search(key,type_id); if (!tm) return 0; Append(str,tm->code); + Swig_temp_result(str); return Char(str); } @@ -1127,8 +924,8 @@ int check_numopt(ParmList *p) { int state = 0; for (;p; p = Getnext(p),i++) { - DataType *pt = Gettype(p); - char *pn = Getname(p); + SwigType *pt = Gettype(p); + String *pn = Getname(p); if (Getvalue(p)) { n++; state = 1; @@ -1167,8 +964,8 @@ typemap_match_parms(ParmList *l) { p = l; while (p) { - DataType *pt = Gettype(p); - char *pn = Getname(p); + SwigType *pt = Gettype(p); + String *pn = Getname(p); ParmList *vars = 0; tm = NewHash(); diff --git a/Source/Swig/Makefile.in b/Source/Swig/Makefile.in index 3f85d573f..c4ebd1499 100644 --- a/Source/Swig/Makefile.in +++ b/Source/Swig/Makefile.in @@ -6,9 +6,9 @@ srcdir = @srcdir@ VPATH = @srcdir@ SRCS = map.c wrapfunc.c naming.c tree.c stype.c scanner.c include.c getopt.c misc.c \ - oldtypes.c parms.c cwrap.c + parms.c cwrap.c OBJS = map.o wrapfunc.o naming.o tree.o stype.o scanner.o include.o getopt.o misc.o \ - oldtypes.o parms.o cwrap.o + parms.o cwrap.o prefix = @prefix@ exec_prefix = @exec_prefix@ diff --git a/Source/Swig/cwrap.c b/Source/Swig/cwrap.c index 9f6c362ab..f93068ccf 100644 --- a/Source/Swig/cwrap.c +++ b/Source/Swig/cwrap.c @@ -23,16 +23,13 @@ static char cvsroot[] = "$Header$"; * Generates a name for the ith argument in an argument list * ----------------------------------------------------------------------------- */ -char * +String * Swig_cparm_name(Parm *p, int i) { - static char name[256]; - sprintf(name,"arg%d",i); + String *name = NewStringf("arg%d",i); if (p) { Setlname(p,name); - return Getlname(p); - } else { - return name; } + return Swig_temp_result(name); } /* ----------------------------------------------------------------------------- @@ -42,36 +39,35 @@ Swig_cparm_name(Parm *p, int i) { * and user defined types to pointers. * ----------------------------------------------------------------------------- */ -char * -Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) { - static DOHString *decl = 0; +String * +Swig_clocal(SwigType *t, String_or_char *name, String_or_char *value) { + String *decl; - if (!decl) decl = NewString(""); - Clear(decl); - switch(DataType_type(t)) { + decl = NewString(""); + switch(SwigType_type(t)) { case T_USER: - DataType_add_pointer(t); + SwigType_add_pointer(t); if (value) - Printf(decl,"%s = &%s", DataType_lstr(t,name), value); + Printf(decl,"%s = &%s", SwigType_lstr(t,name), value); else - Printf(decl,"%s", DataType_lstr(t,name)); - DataType_del_pointer(t); + Printf(decl,"%s", SwigType_lstr(t,name)); + SwigType_del_pointer(t); break; case T_REFERENCE: if (value) - Printf(decl,"%s = &%s", DataType_lstr(t,name), value); + Printf(decl,"%s = &%s", SwigType_lstr(t,name), value); else - Printf(decl,"%s", DataType_lstr(t,name)); + Printf(decl,"%s", SwigType_lstr(t,name)); break; case T_VOID: break; default: if (value) - Printf(decl,"%s = %s", DataType_lstr(t,name), value); + Printf(decl,"%s = %s", SwigType_lstr(t,name), value); else - Printf(decl,"%s", DataType_lstr(t,name)); + Printf(decl,"%s", SwigType_lstr(t,name)); } - return Char(decl); + return Swig_temp_result(decl); } /* ----------------------------------------------------------------------------- @@ -81,23 +77,22 @@ Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value) { * and user defined types to pointers. * ----------------------------------------------------------------------------- */ -DataType * -Swig_clocal_type(DataType *t) { - DataType *ty; - switch(DataType_type(t)) { +SwigType * +Swig_clocal_type(SwigType *t) { + SwigType *ty; + switch(SwigType_type(t)) { case T_USER: - DataType_add_pointer(t); - ty = DataType_ltype(t); - DataType_del_pointer(t); + SwigType_add_pointer(t); + ty = SwigType_ltype(t); + SwigType_del_pointer(t); break; default: - ty = DataType_ltype(t); + ty = SwigType_ltype(t); break; } return ty; } - /* ----------------------------------------------------------------------------- * Swig_clocal_deref() * @@ -105,22 +100,19 @@ Swig_clocal_type(DataType *t) { * the Swig_clocal() function. * ----------------------------------------------------------------------------- */ -char * -Swig_clocal_deref(DataType *t, DOHString_or_char *name) { - static char temp[256]; - - switch(DataType_type(t)) { +String * +Swig_clocal_deref(SwigType *t, String_or_char *name) { + switch(SwigType_type(t)) { case T_USER: - sprintf(temp,"*%s",Char(name)); + return Swig_temp_result(NewStringf("*%s",name)); break; case T_VOID: - strcpy(temp,""); + return Swig_temp_result(NewString("")); break; default: - sprintf(temp,DataType_rcaststr(t,name)); + return SwigType_rcaststr(t,name); break; } - return temp; } /* ----------------------------------------------------------------------------- @@ -129,21 +121,19 @@ Swig_clocal_deref(DataType *t, DOHString_or_char *name) { * Assigns a value to a local * ----------------------------------------------------------------------------- */ -char * -Swig_clocal_assign(DataType *t, DOHString_or_char *name) { - static char temp[256]; - switch(DataType_type(t)) { +String * +Swig_clocal_assign(SwigType *t, String_or_char *name) { + switch(SwigType_type(t)) { case T_VOID: - strcpy(temp,""); + return Swig_temp_result(NewString("")); break; case T_USER: - sprintf(temp,"&%s",Char(name)); + return Swig_temp_result(NewStringf("&%s", name)); break; default: - sprintf(temp,DataType_lcaststr(t,name)); + return SwigType_lcaststr(t,name); break; } - return temp; } /* ----------------------------------------------------------------------------- @@ -155,11 +145,11 @@ Swig_clocal_assign(DataType *t, DOHString_or_char *name) { int Swig_cargs(Wrapper *w, ParmList *p) { int i; - DataType *pt; - char *pvalue; - char *pname; - char *local; - char *lname; + SwigType *pt; + String *pvalue; + String *pname; + String *local; + String *lname; i = 0; while (p != 0) { @@ -182,42 +172,38 @@ int Swig_cargs(Wrapper *w, ParmList *p) { * function call. * ----------------------------------------------------------------------------- */ -void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) { - DOHString *fcall; +void Swig_cresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl) { + String *fcall; fcall = NewString(""); - if (DataType_type(t) != T_VOID) + if (SwigType_type(t) != T_VOID) Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0); - switch(DataType_type(t)) { + switch(SwigType_type(t)) { case T_VOID: break; case T_USER: - DataType_add_pointer(t); - Printv(fcall, name, " = (", DataType_lstr(t,0), ") malloc(sizeof(", 0); - DataType_del_pointer(t); - Printv(fcall, DataType_str(t,0), "));\n", 0); - Printv(fcall, "*(", name, ") = ", 0); + SwigType_add_pointer(t); + Printf(fcall,"%s = (%s) malloc(sizeof(", name, SwigType_lstr(t,0)); + SwigType_del_pointer(t); + Printf(fcall, "%s));\n", SwigType_str(t,0)); + Printf(fcall, "*(%s) = ", name); break; case T_REFERENCE: - Printv(fcall, DataType_str(t,"_result_ref")," = ", 0); + Printf(fcall,"%s = ", SwigType_str(t,"_result_ref")); break; default: /* Normal return value */ - if (DataType_qualifier(t)) { - Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0); - } else { - Printv(fcall, name, " = ", 0); - } + Printf(fcall,"%s = (%s)", name, SwigType_lstr(t,0)); break; } /* Now print out function call */ Printv(fcall, decl, ";\n", 0); - if (DataType_type(t) == T_REFERENCE) { - Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0); + if (SwigType_type(t) == T_REFERENCE) { + Printf(fcall,"%s = (%s) &_result_ref;\n", name, SwigType_lstr(t,0)); } if (Replace(w->code,"$function",fcall, DOH_REPLACE_ANY) == 0) { @@ -233,37 +219,37 @@ void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or * the C++ default copy constructor for user defined objects. * ----------------------------------------------------------------------------- */ -void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) { - DOHString *fcall; +void Swig_cppresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl) { + String *fcall; fcall = NewString(""); - if (DataType_type(t) != T_VOID) + if (SwigType_type(t) != T_VOID) Wrapper_add_localv(w,name, Swig_clocal(t,name,0), 0); - switch(DataType_type(t)) { + switch(SwigType_type(t)) { case T_VOID: break; case T_USER: - Printv(fcall, name, " = new ", DataType_str(t,0), "(", 0); + Printf(fcall, "%s = new %s(", name, SwigType_str(t,0)); break; case T_REFERENCE: - Printv(fcall, DataType_str(t,"_result_ref")," = ", 0); + Printf(fcall, "%s = ", SwigType_str(t,"_result_ref")); break; default: - Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0); + Printf(fcall, "%s = %s", name, SwigType_lcaststr(t,"")); break; } /* Now print out function call */ Printv(fcall, decl, 0); - switch(DataType_type(t)) { + switch(SwigType_type(t)) { case T_USER: Printf(fcall,");"); break; case T_REFERENCE: Printf(fcall,";\n"); - Printv(fcall, name, " = (", DataType_lstr(t,0), ") &_result_ref;\n", 0); + Printf(fcall, "%s = (%s) &_result_ref;\n", name, SwigType_lstr(t,0)); break; default: Printf(fcall,";\n"); @@ -286,27 +272,27 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_ * * ----------------------------------------------------------------------------- */ -char * -Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) { - static DOH *func = 0; +String * +Swig_cfunction_call(String_or_char *name, ParmList *parms) { + DOH *func; int i = 0; Parm *p = parms; - DataType *pt; - - if (!func) func = NewString(""); - Clear(func); + SwigType *pt; + func = NewString(""); Printf(func,"%s(", name); while (p) { + String *pname; pt = Gettype(p); - Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i))); + pname = Swig_cparm_name(p,i); + Printf(func,"%s", Swig_clocal_deref(pt, pname)); i++; p = Getnext(p); if (p) Printf(func,","); } Printf(func,")"); - return Char(func); + return Swig_temp_result(func); } /* ----------------------------------------------------------------------------- @@ -318,30 +304,30 @@ Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) { * * ----------------------------------------------------------------------------- */ -char * -Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) { - static DOH *func = 0; +String * +Swig_cmethod_call(String_or_char *name, ParmList *parms) { + DOH *func; int i = 0; Parm *p = parms; - DataType *pt; + SwigType *pt; - if (!func) func = NewString(""); - Clear(func); - - if (!p) return ""; + func = NewString(""); + if (!p) return Swig_temp_result(func); Printf(func,"%s->%s(", Swig_cparm_name(p,0), name); i++; p = Getnext(p); while (p) { + String *pname; pt = Gettype(p); - Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i))); + pname = Swig_cparm_name(p,i); + Printf(func,"%s", Swig_clocal_deref(pt, pname)); i++; p = Getnext(p); if (p) Printf(func,","); } Printf(func,")"); - return Char(func); + return Swig_temp_result(func); } /* ----------------------------------------------------------------------------- @@ -352,15 +338,13 @@ Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) { * (name *) calloc(1,sizeof(name)); * ----------------------------------------------------------------------------- */ -char * -Swig_cconstructor_call(DOHString_or_char *name) { - static DOH *func = 0; - - if (!func) func = NewString(""); - Clear(func); +String * +Swig_cconstructor_call(String_or_char *name) { + DOH *func; + func = NewString(""); Printf(func,"(%s *) calloc(1, sizeof(%s))", name, name); - return Char(func); + return Swig_temp_result(func); } @@ -374,26 +358,26 @@ Swig_cconstructor_call(DOHString_or_char *name) { * * ----------------------------------------------------------------------------- */ -char * -Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) { - static DOH *func = 0; +String * +Swig_cppconstructor_call(String_or_char *name, ParmList *parms) { + DOH *func; int i = 0; Parm *p = parms; - DataType *pt; - if (!func) func = NewString(""); - Clear(func); - + SwigType *pt; + func = NewString(""); Printf(func,"new %s(", name); while (p) { + String *pname; pt = Gettype(p); - Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i))); + pname = Swig_cparm_name(p,i); + Printf(func,"%s", Swig_clocal_deref(pt, pname)); i++; p = Getnext(p); if (p) Printf(func,","); } Printf(func,")"); - return Char(func); + return Swig_temp_result(func); } @@ -405,15 +389,14 @@ Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) { * free((char *) arg0); * ----------------------------------------------------------------------------- */ -char * +String * Swig_cdestructor_call() { - static DOH *func = 0; + DOH *func; - if (!func) func = NewString(""); - Clear(func); + func = NewString(""); Printf(func,"free((char *) %s)", Swig_cparm_name(0,0)); - return Char(func); + return Swig_temp_result(func); } @@ -425,15 +408,13 @@ Swig_cdestructor_call() { * delete arg0; * ----------------------------------------------------------------------------- */ -char * +String * Swig_cppdestructor_call() { - static DOH *func = 0; - - if (!func) func = NewString(""); - Clear(func); + DOH *func; + func = NewString(""); Printf(func,"delete %s", Swig_cparm_name(0,0)); - return Char(func); + return Swig_temp_result(func); } /* ----------------------------------------------------------------------------- @@ -445,21 +426,20 @@ Swig_cppdestructor_call() { * * ----------------------------------------------------------------------------- */ -char * -Swig_cmemberset_call(DOHString_or_char *name, DataType *type) { - static DOH *func = 0; +String * +Swig_cmemberset_call(String_or_char *name, SwigType *type) { + DOH *func; + String *pname; + func = NewString(""); - if (!func) func = NewString(""); - Clear(func); - - if (DataType_type(type) == T_USER) { + if (SwigType_type(type) == T_USER) { Printf(func,"%s %s->%s; ", Swig_clocal_assign(type,""), Swig_cparm_name(0,0), name); } else { Printf(func,"%s ", Swig_clocal_assign(type,"")); } Printf(func,"(%s->%s = ", Swig_cparm_name(0,0), name); - Printf(func,"%s)", Swig_clocal_deref(type, Swig_cparm_name(0,1))); - return Char(func); + Printf(func,"%s)", Swig_clocal_deref(type, (pname = Swig_cparm_name(0,1)))); + return Swig_temp_result(func); } @@ -472,15 +452,13 @@ Swig_cmemberset_call(DOHString_or_char *name, DataType *type) { * * ----------------------------------------------------------------------------- */ -char * -Swig_cmemberget_call(DOHString_or_char *name, DataType *t) { - static DOH *func = 0; - - if (!func) func = NewString(""); - Clear(func); +String * +Swig_cmemberget_call(String_or_char *name, SwigType *t) { + DOH *func; + func = NewString(""); Printf(func,"%s (%s->%s)", Swig_clocal_assign(t,""),Swig_cparm_name(0,0), name); - return Char(func); + return Swig_temp_result(func); } @@ -505,10 +483,10 @@ static void fix_parm_names(ParmList *p) { * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cfunction_wrapper(DOHString_or_char *funcname, - DataType *rtype, +Swig_cfunction_wrapper(String_or_char *funcname, + SwigType *rtype, ParmList *parms, - DOHString_or_char *code) + String_or_char *code) { Wrapper *w; ParmList *l; @@ -520,7 +498,7 @@ Swig_cfunction_wrapper(DOHString_or_char *funcname, l = CopyParmList(parms); fix_parm_names(l); - Printf(w->def,"%s %s(%s) {", DataType_str(rtype,0), funcname, ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(rtype,0), funcname, ParmList_str(l)); if (code) { Printv(w->code, code, "\n", 0); } @@ -540,16 +518,16 @@ Swig_cfunction_wrapper(DOHString_or_char *funcname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cmethod_wrapper(DOHString_or_char *classname, - DOHString_or_char *methodname, - DataType *rtype, +Swig_cmethod_wrapper(String_or_char *classname, + String_or_char *methodname, + SwigType *rtype, ParmList *parms, - DOHString_or_char *code) + String_or_char *code) { Wrapper *w; ParmList *l; Parm *p; - DataType *t; + SwigType *t; w = NewWrapper(); @@ -557,21 +535,20 @@ Swig_cmethod_wrapper(DOHString_or_char *classname, Wrapper_Setname(w,Swig_name_member(classname, methodname)); l = CopyParmList(parms); - t = NewDataType(T_USER); - DataType_Setname(t, Char(classname)); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); p = NewParm(t,"self"); Setnext(p,l); - DelDataType(t); + Delete(t); l = p; fix_parm_names(l); - Printf(w->def,"%s %s(%s) {", DataType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ - if (DataType_type(rtype) != T_VOID) { + if (SwigType_type(rtype) != T_VOID) { Printf(w->code,"return "); } @@ -603,13 +580,13 @@ Swig_cmethod_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cconstructor_wrapper(DOHString_or_char *classname, +Swig_cconstructor_wrapper(String_or_char *classname, ParmList *parms, - DOHString_or_char *code) + String_or_char *code) { Wrapper *w; ParmList *l; - DataType *t; + SwigType *t; w = NewWrapper(); @@ -617,18 +594,17 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname, Wrapper_Setname(w,Swig_name_construct(classname)); l = CopyParmList(parms); - t = NewDataType(T_USER); - DataType_Setname(t,classname); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); /* Patch up the argument names */ fix_parm_names(l); - Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_construct(classname), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_construct(classname), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ - Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", DataType_str(t,0), classname); + Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", SwigType_str(t,0), classname); } else { Printv(w->code, code, "\n", 0); } @@ -636,11 +612,10 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,t); Wrapper_Setparms(w,l); Delete(l); - DelDataType(t); + Delete(t); return w; } - /* ----------------------------------------------------------------------------- * Swig_cppconstructor_wrapper() * @@ -648,13 +623,13 @@ Swig_cconstructor_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cppconstructor_wrapper(DOHString_or_char *classname, +Swig_cppconstructor_wrapper(String_or_char *classname, ParmList *parms, - DOHString_or_char *code) + String_or_char *code) { Wrapper *w; ParmList *l; - DataType *t; + SwigType *t; Parm *p; w = NewWrapper(); @@ -663,18 +638,17 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname, Wrapper_Setname(w,Swig_name_construct(classname)); l = CopyParmList(parms); - t = NewDataType(T_USER); - DataType_Setname(t,classname); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); /* Patch up the argument names */ fix_parm_names(l); - Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_construct(classname), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_construct(classname), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ - Printf(w->code,"return new %s", DataType_str(t,0)); + Printf(w->code,"return new %s", SwigType_str(t,0)); p = l; if (p) { Printf(w->code,"("); @@ -694,7 +668,7 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,t); Wrapper_Setparms(w,l); Delete(l); - DelDataType(t); + Delete(t); return w; } @@ -706,12 +680,12 @@ Swig_cppconstructor_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cdestructor_wrapper(DOHString_or_char *classname, - DOHString_or_char *code) +Swig_cdestructor_wrapper(String_or_char *classname, + String_or_char *code) { Wrapper *w; ParmList *l; - DataType *t; + SwigType *t; Parm *p; w = NewWrapper(); @@ -719,16 +693,15 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname, /* Set the name of the function */ Wrapper_Setname(w,Swig_name_destroy(classname)); - t = NewDataType(T_USER); - DataType_Setname(t,classname); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); p = NewParm(t,"self"); l = p; - DelDataType(t); + Delete(t); - t = NewDataType(T_VOID); + t = NewString("void"); - Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_destroy(classname), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -740,7 +713,7 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,t); Wrapper_Setparms(w,l); Delete(l); - DelDataType(t); + Delete(t); return w; } @@ -752,12 +725,12 @@ Swig_cdestructor_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cppdestructor_wrapper(DOHString_or_char *classname, - DOHString_or_char *code) +Swig_cppdestructor_wrapper(String_or_char *classname, + String_or_char *code) { Wrapper *w; ParmList *l; - DataType *t; + SwigType *t; Parm *p; w = NewWrapper(); @@ -765,17 +738,16 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname, /* Set the name of the function */ Wrapper_Setname(w,Swig_name_destroy(classname)); - t = NewDataType(T_USER); - DataType_Setname(t,classname); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); p = NewParm(t,"self"); l = p; - DelDataType(t); + Delete(t); - t = NewDataType(T_VOID); + t = NewString("void"); - Printf(w->def,"%s %s(%s) {", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(t,0), Swig_name_destroy(classname), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -787,7 +759,7 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,t); Wrapper_Setparms(w,l); Delete(l); - DelDataType(t); + Delete(t); return w; } @@ -798,34 +770,33 @@ Swig_cppdestructor_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cmemberset_wrapper(DOHString_or_char *classname, - DOHString_or_char *membername, - DataType *type, - DOHString_or_char *code) +Swig_cmemberset_wrapper(String_or_char *classname, + String_or_char *membername, + SwigType *type, + String_or_char *code) { Wrapper *w; ParmList *l; Parm *p; - DataType *t; - DataType *lt; + SwigType *t; + SwigType *lt; w = NewWrapper(); /* Set the name of the function */ Wrapper_Setname(w,Swig_name_member(classname, Swig_name_set(membername))); - t = NewDataType(T_USER); - DataType_Setname(t, Char(classname)); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); p = NewParm(t,"self"); l = p; - DelDataType(t); + Delete(t); lt = Swig_clocal_type(type); p = NewParm(lt,"value"); Setnext(l,p); - Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -838,7 +809,7 @@ Swig_cmemberset_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,lt); Wrapper_Setparms(w,l); Delete(l); - DelDataType(lt); + Delete(lt); return w; } @@ -850,31 +821,30 @@ Swig_cmemberset_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cmemberget_wrapper(DOHString_or_char *classname, - DOHString_or_char *membername, - DataType *type, - DOHString_or_char *code) +Swig_cmemberget_wrapper(String_or_char *classname, + String_or_char *membername, + SwigType *type, + String_or_char *code) { Wrapper *w; ParmList *l; Parm *p; - DataType *t; - DataType *lt; + SwigType *t; + SwigType *lt; w = NewWrapper(); /* Set the name of the function */ Wrapper_Setname(w,Swig_name_member(classname, Swig_name_get(membername))); - t = NewDataType(T_USER); - DataType_Setname(t, Char(classname)); - DataType_add_pointer(t); + t = NewString(classname); + SwigType_add_pointer(t); p = NewParm(t,"self"); l = p; - DelDataType(t); + Delete(t); lt = Swig_clocal_type(type); - Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -886,7 +856,7 @@ Swig_cmemberget_wrapper(DOHString_or_char *classname, Wrapper_Settype(w,lt); Wrapper_Setparms(w,l); Delete(l); - DelDataType(lt); + Delete(lt); return w; } @@ -897,14 +867,14 @@ Swig_cmemberget_wrapper(DOHString_or_char *classname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cvarset_wrapper(DOHString_or_char *varname, - DataType *type, - DOHString_or_char *code) +Swig_cvarset_wrapper(String_or_char *varname, + SwigType *type, + String_or_char *code) { Wrapper *w; ParmList *l; Parm *p; - DataType *lt; + SwigType *lt; w = NewWrapper(); @@ -915,7 +885,7 @@ Swig_cvarset_wrapper(DOHString_or_char *varname, p = NewParm(lt,"value"); l = p; - Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -925,14 +895,14 @@ Swig_cvarset_wrapper(DOHString_or_char *varname, Printv(w->code, code, "\n", 0); Replace(w->code,"$target",varname, DOH_REPLACE_ANY); Replace(w->code,"$source","value", DOH_REPLACE_ANY); - Replace(w->code,"$ltype", DataType_str(lt,""), DOH_REPLACE_ANY); - Replace(w->code,"$rtype", DataType_str(type,""), DOH_REPLACE_ANY); + Replace(w->code,"$ltype", SwigType_str(lt,""), DOH_REPLACE_ANY); + Replace(w->code,"$rtype", SwigType_str(type,""), DOH_REPLACE_ANY); } Printf(w->code,"}\n"); Wrapper_Settype(w,lt); Wrapper_Setparms(w,l); Delete(l); - DelDataType(lt); + Delete(lt); return w; } @@ -943,13 +913,13 @@ Swig_cvarset_wrapper(DOHString_or_char *varname, * ----------------------------------------------------------------------------- */ Wrapper * -Swig_cvarget_wrapper(DOHString_or_char *varname, - DataType *type, - DOHString_or_char *code) +Swig_cvarget_wrapper(String_or_char *varname, + SwigType *type, + String_or_char *code) { Wrapper *w; ParmList *l = 0; - DataType *lt; + SwigType *lt; w = NewWrapper(); @@ -958,7 +928,7 @@ Swig_cvarget_wrapper(DOHString_or_char *varname, lt = Swig_clocal_type(type); - Printf(w->def,"%s %s(%s) {", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); + Printf(w->def,"%s %s(%s) {", SwigType_str(lt,0), Wrapper_Getname(w), ParmList_str(l)); if (!code) { /* No code supplied. Write a function manually */ @@ -970,7 +940,7 @@ Swig_cvarget_wrapper(DOHString_or_char *varname, Wrapper_Settype(w,lt); Wrapper_Setparms(w,l); Delete(l); - DelDataType(lt); + Delete(lt); return w; } diff --git a/Source/Swig/include.c b/Source/Swig/include.c index 39b3bc804..a9e88f2a9 100644 --- a/Source/Swig/include.c +++ b/Source/Swig/include.c @@ -17,8 +17,8 @@ static char cvsroot[] = "$Header$"; /* Delimeter used in accessing files and directories */ -static DOHList *directories = 0; /* List of include directories */ -static DOHString *lastpath = 0; /* Last file that was included */ +static List *directories = 0; /* List of include directories */ +static String *lastpath = 0; /* Last file that was included */ static int bytes_read = 0; /* Bytes read */ /* ----------------------------------------------------------------------------- @@ -28,7 +28,7 @@ static int bytes_read = 0; /* Bytes read */ * ----------------------------------------------------------------------------- */ void -Swig_add_directory(const DOHString_or_char *dirname) { +Swig_add_directory(const String_or_char *dirname) { if (!directories) directories = NewList(); assert(directories); if (!DohIsString(dirname)) { @@ -44,7 +44,7 @@ Swig_add_directory(const DOHString_or_char *dirname) { * Returns the full pathname of the last file opened. * ----------------------------------------------------------------------------- */ -DOHString * +String * Swig_last_file() { assert(lastpath); return lastpath; @@ -56,11 +56,11 @@ Swig_last_file() { * Returns a list of the current search paths. * ----------------------------------------------------------------------------- */ -DOHList * +List * Swig_search_path() { - DOHString *filename; - DOHString *dirname; - DOHList *slist; + String *filename; + String *dirname; + List *slist; int i; slist = NewList(); @@ -86,10 +86,10 @@ Swig_search_path() { * ----------------------------------------------------------------------------- */ FILE * -Swig_open(const DOHString_or_char *name) { +Swig_open(const String_or_char *name) { FILE *f; - DOHString *filename; - DOHList *spath = 0; + String *filename; + List *spath = 0; char *cname; int i; @@ -124,10 +124,10 @@ Swig_open(const DOHString_or_char *name) { * Reads data from an open FILE * and returns it as a string. * ----------------------------------------------------------------------------- */ -DOHString * +String * Swig_read_file(FILE *f) { char buffer[4096]; - DOHString *str = NewString(""); + String *str = NewString(""); assert(str); while (fgets(buffer,4095,f)) { @@ -144,10 +144,10 @@ Swig_read_file(FILE *f) { * ----------------------------------------------------------------------------- */ static int readbytes = 0; -DOHString * -Swig_include(const DOHString_or_char *name) { +String * +Swig_include(const String_or_char *name) { FILE *f; - DOHString *str; + String *str; f = Swig_open(name); if (!f) return 0; @@ -173,7 +173,7 @@ Swig_bytes_read() { * ----------------------------------------------------------------------------- */ int -Swig_insert_file(const DOHString_or_char *filename, DOHFile *outfile) { +Swig_insert_file(const String_or_char *filename, File *outfile) { char buffer[4096]; int nbytes; FILE *f = Swig_open(filename); diff --git a/Source/Swig/map.c b/Source/Swig/map.c index 596b2ddfe..ed788cbab 100644 --- a/Source/Swig/map.c +++ b/Source/Swig/map.c @@ -52,17 +52,17 @@ static char cvsroot[] = "$Header$"; * ----------------------------------------------------------------------------- */ void -Swig_map_add_parmrule(DOHHash *ruleset, DOHHash *parms, DOH *obj) +Swig_map_add_parmrule(Hash *ruleset, Hash *parms, DOH *obj) { - DOHHash *p, *n; + Hash *p, *n; /* Walk down the parms list and create a series of hash tables */ p = parms; n = ruleset; while (p) { - DOHString *ty, *name, *key; - DOHHash *nn; + String *ty, *name, *key; + Hash *nn; ty = Getattr(p,"type"); name = Getattr(p,"name"); @@ -95,8 +95,8 @@ Swig_map_add_parmrule(DOHHash *ruleset, DOHHash *parms, DOH *obj) * ----------------------------------------------------------------------------- */ void -Swig_map_add_typerule(DOHHash *ruleset, DOH *type, DOHString_or_char *name, DOH *obj) { - DOHHash *p; +Swig_map_add_typerule(Hash *ruleset, DOH *type, String_or_char *name, DOH *obj) { + Hash *p; p = NewHash(); Setattr(p,"type",type); @@ -109,8 +109,8 @@ Swig_map_add_typerule(DOHHash *ruleset, DOH *type, DOHString_or_char *name, DOH typedef struct MatchObject { - DOH *ruleset; /* Hash table of rules */ - DOHHash *p; /* Parameter on which checking starts */ + Hash *ruleset; /* Hash table of rules */ + Hash *p; /* Parameter on which checking starts */ int depth; /* Depth of the match */ struct MatchObject *next; /* Next match object */ } MatchObject; @@ -131,7 +131,7 @@ static MatchObject *matchstack = 0; * ----------------------------------------------------------------------------- */ DOH * -Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch) +Swig_map_match_parms(Hash *ruleset, Hash *parms, int *nmatch) { MatchObject *mo; @@ -151,15 +151,15 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch) /* Loop over all candidates until we find the best one */ while (matchstack) { - DOHHash *rs; - DOHHash *p; - int depth = 0; - DOH *obj; - DOHString *key; - DOHString *ty; - DOHString *name; - DOHString *nm; - int matched = 0; + Hash *rs; + Hash *p; + int depth = 0; + DOH *obj; + String *key; + String *ty; + String *name; + String *nm; + int matched = 0; mo = matchstack; /* See if there is a match at this level */ @@ -223,7 +223,7 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch) int ndim; int i, j, n; int ncheck; - DOHString *ntype; + String *ntype; key = NewString(""); @@ -304,8 +304,8 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch) } else { /* If there is no match at all. I guess we can check for a default type */ DOH *rs; - DOHString *key; - DOHString *dty = SwigType_default(Getattr(parms,"type")); + String *key; + String *dty = SwigType_default(Getattr(parms,"type")); key = NewStringf("*map:-%s",dty); rs = Getattr(ruleset,key); @@ -332,8 +332,8 @@ Swig_map_match_parms(DOHHash *ruleset, DOHHash *parms, int *nmatch) * ----------------------------------------------------------------------------- */ DOH * -Swig_map_match_type(DOHHash *ruleset, DOH *type, DOHString_or_char *name) { - DOHHash *p; +Swig_map_match_type(Hash *ruleset, DOH *type, String_or_char *name) { + Hash *p; DOH *obj; int nmatch; diff --git a/Source/Swig/misc.c b/Source/Swig/misc.c index feb4e5f1b..dbf226f16 100644 --- a/Source/Swig/misc.c +++ b/Source/Swig/misc.c @@ -37,7 +37,7 @@ Swig_copy_string(const char *s) { * ----------------------------------------------------------------------------- */ void -Swig_banner(DOHFile *f) { +Swig_banner(File *f) { Printf(f, "/* ----------------------------------------------------------------------------\n\ * This file was automatically generated by SWIG (http://www.swig.org).\n\ @@ -56,6 +56,48 @@ Swig_banner(DOHFile *f) { } +/* ----------------------------------------------------------------------------- + * Swig_temp_result() + * + * This function is used to return a "temporary" result--a result that is only + * guaranteed to exist for a short period of time. Typically this is used by + * functions that return strings and other intermediate results that are + * used in print statements. + * + * Note: this is really a bit of a kludge to make it easier to work with + * temporary variables (so that the caller doesn't have to worry about + * memory management). In theory, it is possible to break this if an + * operation produces so many temporaries that it overflows the internal + * array before they are used. However, in practice, this would only + * occur for very deep levels of recursion or functions taking lots of + * parameters---neither of which occur very often in SWIG (if at all). + * Also, a user can prevent destruction of a temporary object by increasing + * it's reference count using DohIncref(). + * + * It is an error to place two identical results onto this list. It is also + * an error for a caller to free anything returned by this function. + * + * Note: SWIG1.1 did something similar to this in a less-organized manner. + * ----------------------------------------------------------------------------- */ + +#define MAX_RESULT 512 + +static DOH *results[MAX_RESULT]; +static int results_index = 0; +static int results_init = 0; + +DOH *Swig_temp_result(DOH *x) { + int i; + if (!results_init) { + for (i = 0; i < MAX_RESULT; i++) results[i] = 0; + results_init = 1; + } + /* Printf(stdout,"results_index = %d, %x, '%s'\n", results_index, x, x); */ + if (results[results_index]) Delete(results[results_index]); + results[results_index] = x; + results_index = (results_index + 1) % MAX_RESULT; + return x; +} diff --git a/Source/Swig/naming.c b/Source/Swig/naming.c index 90ab9e56f..be61338c6 100644 --- a/Source/Swig/naming.c +++ b/Source/Swig/naming.c @@ -16,7 +16,7 @@ static char cvsroot[] = "$Header$"; /* Hash table containing naming data */ -static DOH *naming_hash = 0; +static Hash *naming_hash = 0; /* ----------------------------------------------------------------------------- * Swig_name_register() @@ -24,7 +24,8 @@ static DOH *naming_hash = 0; * Register a new naming format. * ----------------------------------------------------------------------------- */ -void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format) { +void +Swig_name_register(String_or_char *method, String_or_char *format) { if (!naming_hash) naming_hash = NewHash(); Setattr(naming_hash,method,format); } @@ -35,18 +36,17 @@ void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format) { * Converts all of the non-identifier characters of a string to underscores. * ----------------------------------------------------------------------------- */ -char *Swig_name_mangle(DOHString_or_char *s) { - static DOHString *r = 0; +String * +Swig_name_mangle(String_or_char *s) { + String *r = NewString(""); char *c; - if (!r) r = NewString(""); - Clear(r); Append(r,s); c = Char(r); while (*c) { if (!isalnum(*c)) *c = '_'; c++; } - return Char(r); + return Swig_temp_result(r); } /* ----------------------------------------------------------------------------- @@ -55,13 +55,13 @@ char *Swig_name_mangle(DOHString_or_char *s) { * Returns the name of a wrapper function. * ----------------------------------------------------------------------------- */ -char *Swig_name_wrapper(DOHString_or_char *fname) { - static DOHString *r = 0; - DOHString *f; +String * +Swig_name_wrapper(String_or_char *fname) { + String *r; + String *f; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"wrapper"); if (!f) { Append(r,"_wrap_%f"); @@ -69,7 +69,7 @@ char *Swig_name_wrapper(DOHString_or_char *fname) { Append(r,f); } Replace(r,"%f",fname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } @@ -79,14 +79,14 @@ char *Swig_name_wrapper(DOHString_or_char *fname) { * Returns the name of a class method. * ----------------------------------------------------------------------------- */ -char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) { - static DOHString *r = 0; - DOHString *f; +String * +Swig_name_member(String_or_char *classname, String_or_char *mname) { + String *r; + String *f; char *cname, *c; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"member"); if (!f) { Append(r,"%c_%m"); @@ -98,7 +98,7 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) { if (c) cname = c+1; Replace(r,"%c",cname, DOH_REPLACE_ANY); Replace(r,"%m",mname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } /* ----------------------------------------------------------------------------- @@ -107,13 +107,13 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) { * Returns the name of the accessor function used to get a variable. * ----------------------------------------------------------------------------- */ -char *Swig_name_get(DOHString_or_char *vname) { - static DOHString *r = 0; - DOHString *f; +String * +Swig_name_get(String_or_char *vname) { + String *r; + String *f; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"get"); if (!f) { Append(r,"%v_get"); @@ -121,7 +121,7 @@ char *Swig_name_get(DOHString_or_char *vname) { Append(r,f); } Replace(r,"%v",vname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } /* ----------------------------------------------------------------------------- @@ -130,13 +130,13 @@ char *Swig_name_get(DOHString_or_char *vname) { * Returns the name of the accessor function used to set a variable. * ----------------------------------------------------------------------------- */ -char *Swig_name_set(DOHString_or_char *vname) { - static DOHString *r = 0; - DOHString *f; +String * +Swig_name_set(String_or_char *vname) { + String *r; + String *f; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"set"); if (!f) { Append(r,"%v_set"); @@ -144,7 +144,7 @@ char *Swig_name_set(DOHString_or_char *vname) { Append(r,f); } Replace(r,"%v",vname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } /* ----------------------------------------------------------------------------- @@ -153,13 +153,13 @@ char *Swig_name_set(DOHString_or_char *vname) { * Returns the name of the accessor function used to create an object. * ----------------------------------------------------------------------------- */ -char *Swig_name_construct(DOHString_or_char *classname) { - static DOHString *r = 0; - DOHString *f; +String * +Swig_name_construct(String_or_char *classname) { + String *r; + String *f; char *cname, *c; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"construct"); if (!f) { Append(r,"new_%c"); @@ -172,7 +172,7 @@ char *Swig_name_construct(DOHString_or_char *classname) { if (c) cname = c+1; Replace(r,"%c",cname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } @@ -182,13 +182,12 @@ char *Swig_name_construct(DOHString_or_char *classname) { * Returns the name of the accessor function used to destroy an object. * ----------------------------------------------------------------------------- */ -char *Swig_name_destroy(DOHString_or_char *classname) { - static DOHString *r = 0; - DOHString *f; +String *Swig_name_destroy(String_or_char *classname) { + String *r; + String *f; char *cname, *c; - if (!r) r = NewString(""); + r = NewString(""); if (!naming_hash) naming_hash = NewHash(); - Clear(r); f = Getattr(naming_hash,"destroy"); if (!f) { Append(r,"delete_%c"); @@ -201,8 +200,9 @@ char *Swig_name_destroy(DOHString_or_char *classname) { if (c) cname = c+1; Replace(r,"%c",cname, DOH_REPLACE_ANY); - return Char(r); + return Swig_temp_result(r); } + diff --git a/Source/Swig/parms.c b/Source/Swig/parms.c index eb60b7cdc..db6de504e 100644 --- a/Source/Swig/parms.c +++ b/Source/Swig/parms.c @@ -26,11 +26,11 @@ static char cvsroot[] = "$Header$"; * Create a new parameter from datatype 'type' and name 'n'. * ------------------------------------------------------------------------ */ -Parm *NewParm(DataType *type, char *n) { +Parm *NewParm(SwigType *type, String_or_char *n) { Parm *p = NewHash(); if (type) { - Setattr(p,"type", NewVoid(CopyDataType(type), (void (*)(void *)) DelDataType)); + Setattr(p,"type", Copy(type)); } Setattr(p,"name",n); return p; @@ -41,20 +41,20 @@ Parm *NewParm(DataType *type, char *n) { * ------------------------------------------------------------------------ */ Parm *CopyParm(Parm *p) { - DataType *t; + SwigType *t; char *name; char *lname; char *value; int ignore; Parm *np = NewHash(); - t = GetVoid(p,"type"); + t = Getattr(p,"type"); name = GetChar(p,"name"); lname = GetChar(p,"lname"); value = GetChar(p,"value"); ignore = GetInt(p,"ignore"); - Setattr(np,"type",NewVoid(CopyDataType(t), (void (*)(void *)) DelDataType)); + Setattr(np,"type",Copy(t)); if (name) Setattr(np,"name",name); if (lname) @@ -123,20 +123,19 @@ int ParmList_len(ParmList *p) { * Generates a string of parameters * ---------------------------------------------------------------------- */ -char *ParmList_str(ParmList *p) { - static DOHString *out = 0; - DataType *t; +String *ParmList_str(ParmList *p) { + String *out; + SwigType *t; - if (!out) out = NewString(""); - Clear(out); + out = NewString(""); while(p) { t = Gettype(p); - Printf(out,"%s", DataType_str(t,Getname(p))); + Printf(out,"%s", SwigType_str(t,Getname(p))); p = Getnext(p); if (p) Printf(out,","); } - return Char(out); + return Swig_temp_result(out); } /* --------------------------------------------------------------------- @@ -145,20 +144,19 @@ char *ParmList_str(ParmList *p) { * Generate a prototype string. * ---------------------------------------------------------------------- */ -char *ParmList_protostr(ParmList *p) { - static DOHString *out = 0; - DataType *t; +String *ParmList_protostr(ParmList *p) { + String *out; + SwigType *t; - if (!out) out = NewString(""); - Clear(out); + out = NewString(""); while(p) { t = Gettype(p); - Printf(out,"%s", DataType_str(t,0)); + Printf(out,"%s", SwigType_str(t,0)); p = Getnext(p); if (p) Printf(out,","); } - return Char(out); + return Swig_temp_result(out); } diff --git a/Source/Swig/scanner.c b/Source/Swig/scanner.c index a66268ad0..bb2393685 100644 --- a/Source/Swig/scanner.c +++ b/Source/Swig/scanner.c @@ -18,16 +18,16 @@ static char cvsroot[] = "$Header$"; #include struct SwigScanner { - DOHString *text; /* Current token value */ - DOHList *scanobjs; /* Objects being scanned */ - DOHString *str; /* Current object being scanned */ + String *text; /* Current token value */ + List *scanobjs; /* Objects being scanned */ + String *str; /* Current object being scanned */ char *idstart; /* Optional identifier start characters */ int nexttoken; /* Next token to be returned */ int start_line; /* Starting line of certain declarations */ int string_start; int line; int yylen; /* Length of text pushed into text */ - DOHString *file; + String *file; }; /* ----------------------------------------------------------------------------- @@ -95,7 +95,7 @@ SwigScanner_clear(SwigScanner *s) { * ----------------------------------------------------------------------------- */ void -SwigScanner_push(SwigScanner *s, DOHString *txt) { +SwigScanner_push(SwigScanner *s, String *txt) { assert(s && txt); Push(s->scanobjs,txt); if (s->str) Delete(s->str); @@ -125,7 +125,7 @@ SwigScanner_pushtoken(SwigScanner *s, int nt) { * ----------------------------------------------------------------------------- */ void -SwigScanner_set_location(SwigScanner *s, DOHString *file, int line) { +SwigScanner_set_location(SwigScanner *s, String *file, int line) { Setline(s->str,line); Setfile(s->str,file); } @@ -136,7 +136,7 @@ SwigScanner_set_location(SwigScanner *s, DOHString *file, int line) { * Get the current file. * ----------------------------------------------------------------------------- */ -DOHString * +String * SwigScanner_get_file(SwigScanner *s) { return Getfile(s->str); } @@ -671,7 +671,7 @@ SwigScanner_token(SwigScanner *s) { * Return the lexene associated with the last returned token. * ----------------------------------------------------------------------------- */ -DOHString * +String * SwigScanner_text(SwigScanner *s) { return s->text; } diff --git a/Source/Swig/stype.c b/Source/Swig/stype.c index c0afcf0e2..23de30839 100644 --- a/Source/Swig/stype.c +++ b/Source/Swig/stype.c @@ -13,6 +13,7 @@ static char cvsroot[] = "$Header$"; #include "swig.h" +#include /* ----------------------------------------------------------------------------- * Synopsis @@ -62,7 +63,7 @@ static char cvsroot[] = "$Header$"; * For the most part, this module tries to minimize the use of special * characters (*, [, <, etc...) in its type encoding. One reason for this * is that SWIG might be extended to encode data in formats such as XML - * where we might want to do things like this: + * where you might want to do this: * * * p.p.int @@ -74,8 +75,64 @@ static char cvsroot[] = "$Header$"; * blah * * In either case, it's probably best to avoid characters such as '&', '*', or '<'. + * + * Why not use C syntax? Well, C syntax is fairly complicated to parse + * and not particularly easy to manipulate---especially for adding, deleting and + * composing type constructors. The string representation presented here makes + * this pretty easy. + * + * Why not use a bunch of nested data structures? Are you kidding? How + * would that be easier to use than a few simple string operations? * ----------------------------------------------------------------------------- */ + +SwigType *NewSwigType(int t) { + switch(t) { + case T_BOOL: + return NewString("bool"); + break; + case T_INT: + return NewString("int"); + break; + case T_UINT: + return NewString("unsigned int"); + break; + case T_SHORT: + return NewString("short"); + break; + case T_USHORT: + return NewString("unsigned short"); + break; + case T_LONG: + return NewString("long"); + break; + case T_ULONG: + return NewString("unsigned long"); + break; + case T_FLOAT: + return NewString("float"); + break; + case T_DOUBLE: + return NewString("double"); + break; + case T_CHAR: + return NewString("char"); + break; + case T_SCHAR: + return NewString("signed char"); + break; + case T_UCHAR: + return NewString("unsigned char"); + break; + case T_VOID: + return NewString("void"); + break; + default : + return NewString(""); + break; + } +} + /* ----------------------------------------------------------------------------- * SwigType_add_pointer() * @@ -83,10 +140,20 @@ static char cvsroot[] = "$Header$"; * ----------------------------------------------------------------------------- */ void -SwigType_add_pointer(DOHString *t) { +SwigType_add_pointer(SwigType *t) { Insert(t,0,"p."); } +void +SwigType_del_pointer(SwigType *t) { + char *c = Char(t); + if (strncmp(c,"p.",2)) { + printf("Fatal error. SwigType_del_pointer applied to non-pointer.\n"); + abort(); + } + Replace(t,"p.","", DOH_REPLACE_ANY | DOH_REPLACE_FIRST); +} + /* ----------------------------------------------------------------------------- * SwigType_add_array() * @@ -94,7 +161,7 @@ SwigType_add_pointer(DOHString *t) { * ----------------------------------------------------------------------------- */ void -SwigType_add_array(DOHString *t, DOHString *size) { +SwigType_add_array(SwigType *t, String *size) { char temp[256]; sprintf(temp,"a(%s).", Char(size)); Insert(t,0,temp); @@ -107,7 +174,7 @@ SwigType_add_array(DOHString *t, DOHString *size) { * ----------------------------------------------------------------------------- */ void -SwigType_add_reference(DOHString *t) { +SwigType_add_reference(SwigType *t) { Insert(t,0,"r."); } @@ -118,7 +185,7 @@ SwigType_add_reference(DOHString *t) { * ----------------------------------------------------------------------------- */ void -SwigType_add_qualifier(DOHString *t, DOHString *qual) { +SwigType_add_qualifier(SwigType *t, String *qual) { char temp[256]; sprintf(temp,"q(%s).",Char(qual)); Insert(t,0,temp); @@ -132,8 +199,8 @@ SwigType_add_qualifier(DOHString *t, DOHString *qual) { * ----------------------------------------------------------------------------- */ void -SwigType_add_function(DOHString *t, DOHList *parms) { - DOHString *pstr; +SwigType_add_function(SwigType *t, List *parms) { + String *pstr; int i,l; Insert(t,0,")."); @@ -154,9 +221,9 @@ SwigType_add_function(DOHString *t, DOHList *parms) { * Isolate a single element of a type string (delimeted by periods) * ----------------------------------------------------------------------------- */ -static DOHString * +static String * isolate_element(char *c) { - DOHString *result = NewString(""); + String *result = NewString(""); while (*c) { if (*c == '.') { Putc(*c,result); @@ -184,14 +251,14 @@ isolate_element(char *c) { } /* ----------------------------------------------------------------------------- - * SwigType_split(DOH *t) + * SwigType_split() * * Splits a type into it's component parts and returns a list of string. * ----------------------------------------------------------------------------- */ -DOHList *SwigType_split(DOHString_or_char *t) { +List *SwigType_split(SwigType *t) { DOH *item; - DOHList *list; + List *list; char *c; int len; @@ -219,9 +286,9 @@ DOHList *SwigType_split(DOHString_or_char *t) { * Pop off the first type-constructor object and update the type * ----------------------------------------------------------------------------- */ -DOHString *SwigType_pop(DOH *t) +String *SwigType_pop(SwigType *t) { - DOHString *result; + String *result; char *c; if (Len(t) == 0) return 0; @@ -241,7 +308,7 @@ DOHString *SwigType_pop(DOH *t) * Push a type constructor onto the type * ----------------------------------------------------------------------------- */ -void SwigType_push(DOHString *t, DOHString *cons) +void SwigType_push(SwigType *t, String *cons) { if (!cons) return; if (!Len(cons)) return; @@ -259,9 +326,9 @@ void SwigType_push(DOHString *t, DOHString *cons) * Splits a comma separated list of components into strings. * ----------------------------------------------------------------------------- */ -DOHList *SwigType_parmlist(DOHString *p) { +List *SwigType_parmlist(String *p) { DOH *item; - DOHList *list; + List *list; char *c; c = Char(p); @@ -307,8 +374,8 @@ DOHList *SwigType_parmlist(DOHString *p) { * Returns the parameter of an operator as a string * ----------------------------------------------------------------------------- */ -DOHString *SwigType_parm(DOHString *t) { - DOHString *result; +String *SwigType_parm(SwigType *t) { + String *result; char *c; int nparens = 0; @@ -340,39 +407,58 @@ DOHString *SwigType_parm(DOHString *t) { * Testing functions for querying a datatype * ----------------------------------------------------------------------------- */ -int SwigType_ispointer(DOHString_or_char *t) { +int SwigType_ispointer(SwigType *t) { char *c; - c = Char(t); - if (strncmp(c,"p.",2) == 0) return 1; + if (strncmp(c,"p.",2) == 0) { + return 1; + } return 0; } -int SwigType_isreference(DOHString_or_char *t) { +int SwigType_isreference(SwigType *t) { char *c; c = Char(t); - if (strncmp(c,"r.",2) == 0) return 1; + if (strncmp(c,"r.",2) == 0) { + return 1; + } return 0; } -int SwigType_isarray(DOHString_or_char *t) { +int SwigType_isarray(SwigType *t) { char *c; c = Char(t); - if (strncmp(c,"a(",2) == 0) return 1; + if (strncmp(c,"a(",2) == 0) { + return 1; + } return 0; } -int SwigType_isfunction(DOHString_or_char *t) { +int SwigType_isfunction(SwigType *t) { char *c; + c = Char(t); - if (strncmp(c,"f(",2) == 0) return 1; + if (strncmp(c,"f(",2) == 0) { + return 1; + } return 0; } -int SwigType_isqualifier(DOHString_or_char *t) { +int SwigType_isqualifier(SwigType *t) { char *c; c = Char(t); - if (strncmp(c,"q(",2) == 0) return 1; + if (strncmp(c,"q(",2) == 0) { + return 1; + } + return 0; +} + +int SwigType_isconst(SwigType *t) { + char *c; + c = Char(t); + if (strncmp(c,"q(const)",8) == 0) { + return 1; + } return 0; } @@ -382,16 +468,25 @@ int SwigType_isqualifier(DOHString_or_char *t) { * Returns the base name of a datatype. * ----------------------------------------------------------------------------- */ -DOHString *SwigType_base(DOHString *t) { +SwigType *SwigType_base(SwigType *t) { char *c, *d; c = Char(t); d = c + strlen(c); while (d > c) { d--; - if (*d == '.') return NewString(d+1); + if (*d == '.') return Swig_temp_result(NewString(d+1)); } - return NewString(c); + return Swig_temp_result(NewString(c)); +} + +void SwigType_setbase(SwigType *t, String_or_char *n) { + SwigType *p; + p = SwigType_prefix(t); + Clear(t); + Append(t,p); + Append(t,n); + Delete(p); } /* ----------------------------------------------------------------------------- @@ -400,9 +495,9 @@ DOHString *SwigType_base(DOHString *t) { * Returns the prefix of a datatype * ----------------------------------------------------------------------------- */ -DOHString *SwigType_prefix(DOHString *t) { +String *SwigType_prefix(SwigType *t) { char *c, *d; - DOHString *r = 0; + String *r = 0; c = Char(t); d = c + strlen(c); @@ -425,7 +520,7 @@ DOHString *SwigType_prefix(DOHString *t) { * Returns the number of dimensions of an array. * ----------------------------------------------------------------------------- */ -int SwigType_array_ndim(DOHString_or_char *t) { +int SwigType_array_ndim(SwigType *t) { int ndim = 0; char *c = Char(t); @@ -443,15 +538,14 @@ int SwigType_array_ndim(DOHString_or_char *t) { * Get the value of the nth dimension. * ----------------------------------------------------------------------------- */ -DOHString *SwigType_array_getdim(DOHString_or_char *t, int n) { - +String *SwigType_array_getdim(SwigType *t, int n) { char *c = Char(t); while (c && (strncmp(c,"a(",2) == 0) && (n > 0)) { c = strchr(c,'.'); c++; n--; } - if (n == 0) return SwigType_parm(c); + if (n == 0) return Swig_temp_result(SwigType_parm(c)); return 0; } @@ -461,8 +555,8 @@ DOHString *SwigType_array_getdim(DOHString_or_char *t, int n) { * Replace the nth dimension of an array to a new value. * ----------------------------------------------------------------------------- */ -void SwigType_array_setdim(DOHString_or_char *t, int n, DOHString_or_char *rep) { - DOHString *result = 0; +void SwigType_array_setdim(SwigType *t, int n, String_or_char *rep) { + String *result = 0; char temp; char *start; char *c = Char(t); @@ -503,15 +597,14 @@ void SwigType_array_setdim(DOHString_or_char *t, int n, DOHString_or_char *rep) * * ----------------------------------------------------------------------------- */ -DOHString *SwigType_default(DOHString_or_char *t) { - DOHString *r1, *def; - DOHString *r = NewString(t); +SwigType *SwigType_default(SwigType *t) { + String *r1, *def; + String *r = NewString(t); while ((r1 = SwigType_typedef_resolve(r))) { Delete(r); r = r1; } - if (SwigType_ispointer(r)) { def = NewString("p.SWIGPOINTER"); } else if (SwigType_isreference(r)) { @@ -531,12 +624,12 @@ DOHString *SwigType_default(DOHString_or_char *t) { * Create a C string representation of a datatype. * ----------------------------------------------------------------------------- */ -DOHString * -SwigType_str(DOHString *s, DOHString_or_char *id) +String * +SwigType_str(SwigType *s, String_or_char *id) { - DOHString *result; - DOHString *element = 0, *nextelement; - DOHList *elements; + String *result; + String *element = 0, *nextelement; + List *elements; int nelements, i; if (id) { @@ -583,7 +676,6 @@ SwigType_str(DOHString *s, DOHString_or_char *id) p = SwigType_str(Getitem(parms,j),0); Append(result,p); if (j < (plen-1)) Append(result,","); - Delete(p); } Append(result,")"); Delete(parms); @@ -600,7 +692,7 @@ SwigType_str(DOHString *s, DOHString_or_char *id) element = nextelement; } Delete(elements); - return result; + return Swig_temp_result(result); } /* ----------------------------------------------------------------------------- @@ -618,13 +710,15 @@ SwigType_str(DOHString *s, DOHString_or_char *id) * with an equivalent assignable version. * -------------------------------------------------------------------- */ -DOHString * -SwigType_lstr(DOHString *s, DOHString_or_char *id) +String * +SwigType_lstr(SwigType *s, String_or_char *id) { - DOHString *result; - DOHString *element = 0, *nextelement; - DOHList *elements; + String *result; + String *element = 0, *nextelement; + List *elements; int nelements, i; + int firstarray = 1; + SwigType *td; if (id) { result = NewString(Char(id)); @@ -632,7 +726,13 @@ SwigType_lstr(DOHString *s, DOHString_or_char *id) result = NewString(""); } - elements = SwigType_split(s); + td = SwigType_typedef_resolve(s); + if ((td) && (SwigType_isconst(td) || SwigType_isarray(td))) { + elements = SwigType_split(td); + } else { + elements = SwigType_split(s); + } + if (td) Delete(td); nelements = Len(elements); if (nelements > 0) { @@ -651,18 +751,28 @@ SwigType_lstr(DOHString *s, DOHString_or_char *id) Insert(result,0,"("); Append(result,")"); } + firstarray = 0; } else if (SwigType_isreference(element)) { Insert(result,0,"*"); } else if (SwigType_isarray(element)) { - DOH *size; - Insert(result,0,"*"); - while (nextelement && (SwigType_isarray(nextelement))) { - i++; - nextelement = Getitem(elements,i+1); - } - if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) { - Insert(result,0,"("); - Append(result,")"); + if (firstarray) { + Insert(result,0,"*"); + while (nextelement && (SwigType_isarray(nextelement))) { + i++; + nextelement = Getitem(elements,i+1); + } + if ((nextelement) && ((SwigType_isfunction(nextelement) || (SwigType_isarray(nextelement))))) { + Insert(result,0,"("); + Append(result,")"); + } + firstarray = 0; + } else { + DOH *size; + Append(result,"["); + size = SwigType_parm(element); + Append(result,size); + Append(result,"]"); + Delete(size); } } else if (SwigType_isfunction(element)) { DOH *parms, *p; @@ -674,7 +784,6 @@ SwigType_lstr(DOHString *s, DOHString_or_char *id) p = SwigType_str(Getitem(parms,j),0); Append(result,p); if (j < (plen-1)) Append(result,","); - Delete(p); } Append(result,")"); Delete(parms); @@ -686,6 +795,63 @@ SwigType_lstr(DOHString *s, DOHString_or_char *id) element = nextelement; } Delete(elements); + return Swig_temp_result(result); +} + + +/* ----------------------------------------------------------------------------- + * SwigType_ltype(SwigType *ty) + * + * Returns a type object corresponding to the string created by lstr + * ----------------------------------------------------------------------------- */ + +SwigType * +SwigType_ltype(SwigType *s) { + String *result; + String *element, *nextelement; + SwigType *td; + List *elements; + int nelements, i; + int firstarray = 1; + + result = NewString(""); + td = SwigType_typedef_resolve(s); + if ((td) && (SwigType_isconst(td) || SwigType_isarray(td))) { + elements = SwigType_split(td); + } else { + elements = SwigType_split(s); + } + if (td) Delete(td); + nelements = Len(elements); + /* Now, walk the type list and start emitting */ + for (i = 0; i < nelements; i++) { + element = Getitem(elements,i); + if (SwigType_ispointer(element)) { + Append(result,element); + firstarray = 0; + } else if (SwigType_isreference(element)) { + Append(result,"p."); + } else if (SwigType_isarray(element)) { + if (firstarray) { + Append(result,"p."); + while (i < (nelements - 1)) { + element = Getitem(elements,i+1); + if (!SwigType_isarray(element)) break; + i++; + } + firstarray = 0; + } else { + Append(result,element); + } + } else if (SwigType_isfunction(element)) { + Append(result,element); + } else if (SwigType_isqualifier(element)) { + } else { + Append(result,element); + } + element = nextelement; + } + Delete(elements); return result; } @@ -696,16 +862,23 @@ SwigType_lstr(DOHString *s, DOHString_or_char *id) * datatype printed by str(). * ----------------------------------------------------------------------------- */ -DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *name) { - DOHString *result, *cast; - DOHString *element = 0, *nextelement; - DOHList *elements; +String *SwigType_rcaststr(SwigType *s, String_or_char *name) { + String *result, *cast; + String *element = 0, *nextelement; + SwigType *td; + List *elements; int nelements, i; int clear = 1; int firstarray = 1; result = NewString(""); - elements = SwigType_split(s); + td = SwigType_typedef_resolve(s); + if ((td) && (SwigType_isconst(td) || SwigType_isarray(td))) { + elements = SwigType_split(td); + } else { + elements = SwigType_split(s); + } + if (td) Delete(td); nelements = Len(elements); if (nelements > 0) { @@ -724,6 +897,7 @@ DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *name) { Insert(result,0,"("); Append(result,")"); } + firstarray = 0; } else if (SwigType_isreference(element)) { Insert(result,0,"&"); } else if (SwigType_isarray(element)) { @@ -749,7 +923,6 @@ DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *name) { p = SwigType_str(Getitem(parms,j),0); Append(result,p); if (j < (plen-1)) Append(result,","); - Delete(p); } Append(result,")"); Delete(parms); @@ -779,7 +952,7 @@ DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *name) { Append(cast,name); } Delete(result); - return cast; + return Swig_temp_result(cast); } @@ -789,24 +962,48 @@ DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *name) { * Casts a variable from the real type to the local datatype. * ----------------------------------------------------------------------------- */ -DOHString *SwigType_lcaststr(DOHString *s, DOHString_or_char *name) { - DOHString *result; +String *SwigType_lcaststr(SwigType *s, String_or_char *name) { + String *result; result = NewString(""); if (SwigType_isarray(s)) { - Printf(result,"(%S)%s", SwigType_lstr(s,0),name); + Printf(result,"(%s)%s", SwigType_lstr(s,0),name); } else if (SwigType_isreference(s)) { - Printf(result,"(%S)", SwigType_lstr(s,0)); + Printf(result,"(%s)", SwigType_lstr(s,0)); if (name) Printf(result,"&%s", name); } else if (SwigType_isqualifier(s)) { - Printf(result,"(%S)%s", SwigType_lstr(s,0),name); + Printf(result,"(%s)%s", SwigType_lstr(s,0),name); } else { if (name) Append(result,name); } - return result; + return Swig_temp_result(result); +} + +String *SwigType_manglestr_default(SwigType *s) { + char *c; + String *result; + + if (SwigType_istypedef(s)) + result = Copy(s); + else + result = SwigType_ltype(s); + Replace(result,"struct ","", DOH_REPLACE_ANY); + Replace(result,"class ","", DOH_REPLACE_ANY); + Replace(result,"union ","", DOH_REPLACE_ANY); + c = Char(result); + while (*c) { + if (!isalnum(*c)) *c = '_'; + c++; + } + Insert(result,0,"_"); + return Swig_temp_result(result); +} + +String *SwigType_manglestr(SwigType *s) { + return SwigType_manglestr_default(s); } /* ----------------------------------------------------------------------------- @@ -817,9 +1014,9 @@ DOHString *SwigType_lcaststr(DOHString *s, DOHString_or_char *name) { #define MAX_SCOPE 8 -static DOHHash *type_scopes = 0; /* Hash table of scope names */ -static DOHHash *scopes[MAX_SCOPE]; /* List representing the current scope */ -static DOHString *scopenames[MAX_SCOPE]; /* Names of the various scopes */ +static Hash *type_scopes = 0; /* Hash table of scope names */ +static Hash *scopes[MAX_SCOPE]; /* List representing the current scope */ +static String *scopenames[MAX_SCOPE]; /* Names of the various scopes */ static int scope_level = 0; static void init_scopes() { @@ -836,7 +1033,7 @@ static void init_scopes() { * Defines a new typedef. Returns -1 if the type name is already defined. * ----------------------------------------------------------------------------- */ -int SwigType_typedef(DOHString_or_char *type, DOHString_or_char *name) { +int SwigType_typedef(SwigType *type, String_or_char *name) { init_scopes(); if (Getattr(scopes[scope_level],name)) return -1; Setattr(scopes[scope_level],name,type); @@ -875,8 +1072,8 @@ void SwigType_reset_scopes() { * type_scopes hash. * ----------------------------------------------------------------------------- */ -void SwigType_set_scope_name(DOHString_or_char *name) { - DOHString *key; +void SwigType_set_scope_name(String_or_char *name) { + String *key; int i; init_scopes(); scopenames[scope_level] = NewString(Char(name)); @@ -894,10 +1091,10 @@ void SwigType_set_scope_name(DOHString_or_char *name) { * Merges the contents of one scope into the current scope. * ----------------------------------------------------------------------------- */ -void SwigType_merge_scope(DOHHash *scope, DOHString_or_char *prefix) { - DOHString *name; - DOHString *key; - DOHString *type; +void SwigType_merge_scope(Hash *scope, String_or_char *prefix) { + String *name; + String *key; + String *type; init_scopes(); key = Firstkey(scope); @@ -920,9 +1117,9 @@ void SwigType_merge_scope(DOHHash *scope, DOHString_or_char *prefix) { * table for the scope that was popped off. * ----------------------------------------------------------------------------- */ -DOHHash *SwigType_pop_scope() { - DOHHash *s; - DOHString *prefix; +Hash *SwigType_pop_scope() { + Hash *s; + String *prefix; init_scopes(); if (scope_level == 0) return 0; prefix = scopenames[scope_level]; @@ -938,10 +1135,10 @@ DOHHash *SwigType_pop_scope() { * typedef mapping. * ----------------------------------------------------------------------------- */ -DOHString *SwigType_typedef_resolve(DOHString_or_char *t) { - DOHString *base; - DOHString *type; - DOHString *r; +SwigType *SwigType_typedef_resolve(SwigType *t) { + String *base; + String *type; + String *r; int level; init_scopes(); @@ -955,7 +1152,6 @@ DOHString *SwigType_typedef_resolve(DOHString_or_char *t) { level--; } if (level < 0) { - Delete(base); return 0; } r = SwigType_prefix(t); @@ -963,6 +1159,22 @@ DOHString *SwigType_typedef_resolve(DOHString_or_char *t) { return r; } +/* ----------------------------------------------------------------------------- + * SwigType_typedef_resolve_all() + * + * Fully resolve a type down to its most basic datatype + * ----------------------------------------------------------------------------- */ + +SwigType *SwigType_typedef_resolve_all(SwigType *t) { + SwigType *n; + SwigType *r = Copy(t); + + while ((n = SwigType_typedef_resolve(r))) { + Delete(r); + r = n; + } + return r; +} /* ----------------------------------------------------------------------------- * SwigType_istypedef() @@ -970,22 +1182,21 @@ DOHString *SwigType_typedef_resolve(DOHString_or_char *t) { * Checks a typename to see if it is a typedef. * ----------------------------------------------------------------------------- */ -int SwigType_istypedef(DOHString_or_char *t) { - DOHString *base, *type; +int SwigType_istypedef(SwigType *t) { + String *base, *type; int level; + init_scopes(); base = SwigType_base(t); level = scope_level; while (level >= 0) { /* See if we know about this type */ type = Getattr(scopes[scope_level],base); if (type) { - Delete(base); return 1; } level--; } - Delete(base); return 0; } @@ -996,8 +1207,8 @@ int SwigType_istypedef(DOHString_or_char *t) { * if equal, 1 if not. * ----------------------------------------------------------------------------- */ -int SwigType_cmp(DOHString_or_char *tpat, DOHString_or_char *type) { - DOHString *r, *s; +int SwigType_cmp(SwigType *tpat, SwigType *type) { + String *r, *s; char *p, *t; p = Char(tpat); @@ -1018,3 +1229,358 @@ int SwigType_cmp(DOHString_or_char *tpat, DOHString_or_char *type) { } return 1; } + +/* ----------------------------------------------------------------------------- + * SwigType_type() + * + * Returns an integer code describing the datatype. This is only used for + * compatibility with SWIG1.1 language modules and is likely to go away once + * everything is based on typemaps. + * ----------------------------------------------------------------------------- */ + +int SwigType_type(SwigType *t) +{ + char *c; + /* Check for the obvious stuff */ + c = Char(t); + + if (strncmp(c,"p.",2) == 0) { + if (SwigType_type(c+2) == T_CHAR) return T_STRING; + else return T_POINTER; + } + if (strncmp(c,"a(",2) == 0) return T_ARRAY; + if (strncmp(c,"r.",2) == 0) return T_REFERENCE; + + if (strncmp(c,"q(",2) == 0) { + while(*c && (*c != '.')) c++; + if (*c) return SwigType_type(c+1); + return T_ERROR; + } + if (strncmp(c,"f(",2) == 0) return T_FUNCTION; + + /* Look for basic types */ + if (strcmp(c,"int") == 0) return T_INT; + if (strcmp(c,"long") == 0) return T_LONG; + if (strcmp(c,"short") == 0) return T_SHORT; + if (strcmp(c,"unsigned") == 0) return T_UINT; + if (strcmp(c,"unsigned short") == 0) return T_USHORT; + if (strcmp(c,"unsigned long") == 0) return T_ULONG; + if (strcmp(c,"unsigned int") == 0) return T_UINT; + if (strcmp(c,"char") == 0) return T_CHAR; + if (strcmp(c,"signed char") == 0) return T_SCHAR; + if (strcmp(c,"unsigned char") == 0) return T_UCHAR; + if (strcmp(c,"float") == 0) return T_FLOAT; + if (strcmp(c,"double") == 0) return T_DOUBLE; + if (strcmp(c,"void") == 0) return T_VOID; + if (strcmp(c,"bool") == 0) return T_BOOL; + + /* Hmmm. Unknown type */ + if (SwigType_istypedef(t)) { + int r; + SwigType *nt = SwigType_typedef_resolve(t); + r = SwigType_type(nt); + Delete(nt); + return r; + } + return T_USER; +} + +/* ----------------------------------------------------------------------------- + * SwigType_remember() + * + * This function "remembers" a datatype that was used during wrapper code generation + * so that a type-checking table can be generated later on. It is up to the language + * modules to actually call this function--it is not done automatically. + * + * Type tracking is managed through two separate hash tables. The hash 'r_mangled' + * is mapping between mangled type names (used in the target language) and + * fully-resolved C datatypes used in the source input. The second hash 'r_resolved' + * is the inverse mapping that maps fully-resolved C datatypes to all of the mangled + * names in the scripting languages. For example, consider the following set of + * typedef declarations: + * + * typedef double Real; + * typedef double Float; + * typedef double Point[3]; + * + * Now, suppose that the types 'double *', 'Real *', 'Float *', 'double[3]', and + * 'Point' were used in an interface file and "remembered" using this function. + * The hash tables would look like this: + * + * r_mangled { + * _p_double : [ p.double, a(3).double ] + * _p_Real : [ p.double ] + * _p_Float : [ p.double ] + * _Point : [ a(3).double ] + * + * r_resolved { + * p.double : [ _p_double, _p_Real, _p_Float ] + * a(3).double : [ _p_double, _Point ] + * } + * + * Together these two hash tables can be used to determine type-equivalency between + * mangled typenames. To do this, we view the two hash tables as a large graph and + * compute the transitive closure. + * ----------------------------------------------------------------------------- */ + +static Hash *r_mangled = 0; /* Hash mapping mangled types to fully resolved types */ +static Hash *r_resolved = 0; /* Hash mapping resolved types to mangled types */ + +void SwigType_remember(SwigType *t) { + String *mt; + Hash *h; + SwigType *fr; + + if (!r_mangled) { + r_mangled = NewHash(); + r_resolved = NewHash(); + } + + mt = SwigType_manglestr(t); /* Create mangled string */ + fr = SwigType_typedef_resolve_all(t); /* Create fully resolved type */ + h = Getattr(r_mangled,mt); + if (!h) { + h = NewHash(); + Setattr(r_mangled,mt,h); + Delete(h); + } + Setattr(h,fr,mt); + + h = Getattr(r_resolved, fr); + if (!h) { + h = NewHash(); + Setattr(r_resolved,fr,h); + Delete(h); + } + Setattr(h,mt,fr); +} + +/* ----------------------------------------------------------------------------- + * SwigType_equivalent_mangle() + * + * Return a list of all of the mangled typenames that are equivalent to another + * mangled name. This works as follows: For each fully qualified C datatype + * in the r_mangled hash entry, we collect all of the mangled names from the + * r_resolved hash and combine them together in a list (removing duplicate entries). + * ----------------------------------------------------------------------------- */ + +List *SwigType_equivalent_mangle(String *ms, Hash *checked, Hash *found) { + List *l; + Hash *h; + Hash *ch; + Hash *mh; + + if (found) { + h = found; + } else { + h = NewHash(); + } + if (checked) { + ch = checked; + } else { + ch = NewHash(); + } + if (Getattr(ch,ms)) goto check_exit; /* Already checked this type */ + Setattr(h,ms,"1"); + Setattr(ch, ms, "1"); + mh = Getattr(r_mangled,ms); + if (mh) { + String *key; + key = Firstkey(mh); + while (key) { + Hash *rh; + if (Getattr(ch,key)) { + key = Nextkey(mh); + continue; + } + Setattr(ch,key,"1"); + rh = Getattr(r_resolved,key); + if (rh) { + String *rkey; + rkey = Firstkey(rh); + while (rkey) { + Setattr(h,rkey,"1"); + SwigType_equivalent_mangle(rkey,ch,h); + rkey = Nextkey(rh); + } + } + key = Nextkey(mh); + } + } + check_exit: + if (!found) { + l = Hash_keys(h); + Delete(h); + Delete(ch); + return l; + } else { + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * SwigType_inherit() + * + * Record information about inheritance. We keep a hash table that keeps + * a mapping between base classes and all of the classes that are derived + * from them. + * + * subclass is a hash that maps base-classes to all of the classes derived from them. + * ----------------------------------------------------------------------------- */ + +static Hash *subclass = 0; +static Hash *conversions = 0; + +void +SwigType_inherit(String *derived, String *base) { + Hash *h; + if (!subclass) subclass = NewHash(); + + h = Getattr(subclass,base); + if (!h) { + h = NewHash(); + Setattr(subclass,base,h); + } + Setattr(h,derived,"1"); +} + +/* ----------------------------------------------------------------------------- + * SwigType_inherit_equiv() + * + * Modify the type table to handle C++ inheritance + * ----------------------------------------------------------------------------- */ + +void SwigType_inherit_equiv(File *out) { + String *rkey, *bkey, *ckey; + String *prefix, *base; + + Hash *sub; + Hash *rh; + + if (!conversions) conversions = NewHash(); + if (!subclass) subclass = NewHash(); + + rkey = Firstkey(r_resolved); + while (rkey) { + /* rkey is actually a fully qualified type */ + + base = SwigType_base(rkey); + sub = Getattr(subclass,base); + if (!sub) { + Delete(base); + rkey = Nextkey(r_resolved); + continue; + } + + rh = Getattr(r_resolved, rkey); + + /* Hmmm. We actually got a base-class match. We're going to try and patch things up */ + bkey = Firstkey(sub); + while (bkey) { + prefix= SwigType_prefix(rkey); + Append(prefix,bkey); + Setattr(rh,SwigType_manglestr(prefix),prefix); + + ckey = NewStringf("%s+%s",SwigType_manglestr(prefix), SwigType_manglestr(rkey)); + if (!Getattr(conversions,ckey)) { + Printf(out,"static %sTo%s(void *x) {\n", SwigType_manglestr(prefix), SwigType_manglestr(rkey)); + Printf(out," return (void *)((%s) ((%s) x));\n", SwigType_lstr(rkey,0), SwigType_lstr(prefix,0)); + Printf(out,"}\n"); + SetInt(conversions,ckey,1); + } + Delete(ckey); + Delete(prefix); + bkey = Nextkey(sub); + } + rkey = Nextkey(r_resolved); + } +} + +/* ----------------------------------------------------------------------------- + * SwigType_type_table() + * + * Generate the type-table for the type-checker. + * ----------------------------------------------------------------------------- */ + +void +SwigType_emit_type_table(File *f_forward, File *f_table) { + DOH *key; + String *types, *table; + int i = 0; + + if (!r_mangled) { + r_mangled = NewHash(); + r_resolved = NewHash(); + } + + Printf(f_table,"\n/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */\n\n"); + + SwigType_inherit_equiv(f_table); + + +#ifdef DEBUG + Printf(stdout,"---r_mangled---\n"); + Printf(stdout,"%s\n", r_mangled); + + Printf(stdout,"---r_resolved---\n"); + Printf(stdout,"%s\n", r_resolved); + + Printf(stdout,"---subclass---\n"); + Printf(stdout,"%s\n", subclass); + + Printf(stdout,"---scopes[0]---\n"); + Printf(stdout,"%s\n", scopes[0]); + +#endif + table = NewString(""); + types = NewString(""); + Printf(table,"static _swig_type_info *_swig_types_initial[] = {\n"); + key = Firstkey(r_mangled); + Printf(f_forward,"\n/* -------- TYPES TABLE (BEGIN) -------- */\n\n"); + while (key) { + List *el; + String *en; + Printf(f_forward,"#define SWIGTYPE%s _swig_types[%d] \n", key, i); + Printv(types,"static _swig_type_info _swigt_", key, "[] = {", 0); + Printv(types,"{\"", key, "\",0},", 0); + el = SwigType_equivalent_mangle(key,0,0); + for (en = Firstitem(el); en; en = Nextitem(el)) { + String *ckey; + ckey = NewStringf("%s+%s", en, key); + if (Getattr(conversions,ckey)) { + Printf(types,"{\"%s\", %sTo%s},", en, en, key); + } else { + Printf(types,"{\"%s\",0},", en); + } + Delete(ckey); + } + Delete(el); + /* Printv(types, "{\"", key, "\",0},", 0); */ + /* Printv(types, check_equivalent((DataType *)GetVoid(remembered,key)), "};\n", 0);*/ + Printf(types,"{0,0}};\n"); + Printv(table, "_swigt_", key, ", \n", 0); + key = Nextkey(r_mangled); + i++; + } + + Printf(table, "0\n};\n"); + Printf(f_forward,"static _swig_type_info *_swig_types[%d];\n", i+1); + Printf(f_forward,"\n/* -------- TYPES TABLE (END) -------- */\n\n"); + Printf(f_table,"%s\n", types); + Printf(f_table,"%s\n", table); + Printf(f_table,"\n/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */\n\n"); + Delete(types); + Delete(table); +} + + + + + + + + + + + + diff --git a/Source/Swig/swig.h b/Source/Swig/swig.h index 17ff340c5..182aa79d2 100644 --- a/Source/Swig/swig.h +++ b/Source/Swig/swig.h @@ -22,140 +22,57 @@ #include "doh.h" +/* Short names for common data types */ + +typedef DOH String; +typedef DOH Hash; +typedef DOH List; +typedef DOH String_or_char; +typedef DOH File; + /* --- Legacy DataType interface. This is being replaced --- */ -#define T_INT 1 -#define T_SHORT 2 -#define T_LONG 3 -#define T_UINT 4 -#define T_USHORT 5 -#define T_ULONG 6 -#define T_UCHAR 7 -#define T_SCHAR 8 -#define T_BOOL 9 -#define T_DOUBLE 10 -#define T_FLOAT 11 -#define T_CHAR 12 -#define T_USER 13 -#define T_VOID 14 -#define T_STRING 20 -#define T_POINTER 21 -#define T_REFERENCE 22 -#define T_ARRAY 23 - -#define T_SYMBOL 98 -#define T_ERROR 99 - -#define MAX_NAME 96 - -typedef struct DataType { - int _type; /* SWIG Type code */ - char _name[MAX_NAME]; /* Name of type */ - int _is_pointer; /* Is this a pointer */ - int _implicit_ptr; /* Implicit ptr */ - int _is_reference; /* A C++ reference type */ - int _status; /* Is this datatype read-only? */ - char *_qualifier; /* A qualifier string (ie. const). */ - char *_arraystr; /* String containing array part */ - int _id; /* type identifier (unique for every type). */ -} DataType; - -extern DataType *NewDataType(int type); -extern DataType *CopyDataType(DataType *type); -extern void DelDataType(DataType *type); - -int DataType_type(DataType *t); -int DataType_Gettypecode(DataType *t); -void DataType_Settypecode(DataType *t, int type); -void DataType_Setname(DataType *t, char *name); -char *DataType_Getname(DataType *t); - -/* -- New type interface -- */ - -extern char *DataType_str(DataType *, DOHString_or_char *name); /* Exact datatype */ -extern char *DataType_lstr(DataType *, DOHString_or_char *name); /* Assignable datatype */ -extern char *DataType_rcaststr(DataType *, DOHString_or_char *name); /* Cast from lstr to str */ -extern char *DataType_lcaststr(DataType *, DOHString_or_char *name); /* Cast from str to lstr */ -extern char *DataType_manglestr(DataType *t); /* Mangled type name */ -extern DataType *DataType_ltype(DataType *); /* Create local type object */ - -void DataType_add_reference(DataType *t); -int DataType_is_reference(DataType *t); -int DataType_is_pointer(DataType *t); -void DataType_add_pointer(DataType *t); -void DataType_del_pointer(DataType *t); - -/* -- Old type interface. This is going away -- */ - -extern char *DataType_qualifier(DataType *); -extern void DataType_set_qualifier(DataType *, char *q); -extern char *DataType_arraystr(DataType *); -extern void DataType_set_arraystr(DataType *, char *a); - -extern char *DataType_mangle_default(DataType *t); /* Default name mangler */ -extern void DataType_primitive(DataType *); -extern void DataType_set_mangle(char *(*m)(DataType *)); -extern int DataType_array_dimensions(DataType *); -extern char *DataType_get_dimension(DataType *, int); - -/* Typedef support */ -extern int DataType_typedef_add(DataType *, char *name, int mode); -extern void DataType_typedef_resolve(DataType *, int level); -extern void DataType_typedef_replace(DataType *); -extern int DataType_is_typedef(char *name); -extern void DataType_updatestatus(DataType *, int newstatus); -extern void DataType_init_typedef(); -extern void DataType_merge_scope(DOHHash *h); -extern void DataType_new_scope(DOHHash *h); -extern void *DataType_collapse_scope(char *name); -extern void DataType_remember(DataType *); -extern void DataType_record_base(char *derived, char *base); -extern int type_id; -extern void emit_ptr_equivalence(DOHFile *tablef, DOHFile *initf); -extern void emit_type_table(DOHFile *out); -extern void typeeq_derived(char *n1, char *n2, char *cast); -extern void typeeq_addtypedef(char *name, char *eqname, DataType *t); - -#define STAT_REPLACETYPE 2 - -/* --- Parameters and Parameter Lists --- */ - -/* Parameters are really just hidden behind a DOH object. The following - interface will probably be simplified even further. */ - -typedef DOH Parm; - -extern Parm *NewParm(DataType *type, char *n); -extern Parm *CopyParm(Parm *p); - -typedef DOH ParmList; - -extern ParmList *CopyParmList(ParmList *); - -extern int ParmList_len(ParmList *); -extern int ParmList_numarg(ParmList *); -extern char *ParmList_str(ParmList *); -extern char *ParmList_protostr(ParmList *); +#define T_INT 1 +#define T_SHORT 2 +#define T_LONG 3 +#define T_UINT 4 +#define T_USHORT 5 +#define T_ULONG 6 +#define T_UCHAR 7 +#define T_SCHAR 8 +#define T_BOOL 9 +#define T_DOUBLE 10 +#define T_FLOAT 11 +#define T_CHAR 12 +#define T_USER 13 +#define T_VOID 14 +#define T_STRING 20 +#define T_POINTER 21 +#define T_REFERENCE 22 +#define T_ARRAY 23 +#define T_FUNCTION 24 +#define T_SYMBOL 98 +#define T_ERROR 99 /* --- File interface --- */ -extern void Swig_add_directory(const DOHString_or_char *dirname); -extern DOHString *Swig_last_file(); -extern DOHList *Swig_search_path(); -extern FILE *Swig_open(const DOHString_or_char *name); -extern DOHString *Swig_read_file(FILE *f); -extern DOHString *Swig_include(const DOHString_or_char *name); -extern int Swig_insert_file(const DOHString_or_char *name, DOHFile *outfile); -extern int Swig_bytes_read(); +extern void Swig_add_directory(const String_or_char *dirname); +extern String *Swig_last_file(); +extern List *Swig_search_path(); +extern FILE *Swig_open(const String_or_char *name); +extern String *Swig_read_file(FILE *f); +extern String *Swig_include(const String_or_char *name); +extern int Swig_insert_file(const String_or_char *name, File *outfile); +extern int Swig_bytes_read(); #define SWIG_FILE_DELIMETER "/" /* --- Command line parsing --- */ -extern void Swig_init_args(int argc, char **argv); -extern void Swig_mark_arg(int n); -extern void Swig_check_options(); -extern void Swig_arg_error(); +extern void Swig_init_args(int argc, char **argv); +extern void Swig_mark_arg(int n); +extern void Swig_check_options(); +extern void Swig_arg_error(); /* --- Scanner Interface --- */ @@ -164,14 +81,14 @@ typedef struct SwigScanner SwigScanner; extern SwigScanner *NewSwigScanner(); extern void DelSwigScanner(SwigScanner *); extern void SwigScanner_clear(SwigScanner *); -extern void SwigScanner_push(SwigScanner *, DOHString *); +extern void SwigScanner_push(SwigScanner *, String *); extern void SwigScanner_pushtoken(SwigScanner *, int); extern int SwigScanner_token(SwigScanner *); -extern DOHString *SwigScanner_text(SwigScanner *); +extern String *SwigScanner_text(SwigScanner *); extern void SwigScanner_skip_line(SwigScanner *); extern int SwigScanner_skip_balanced(SwigScanner *, int startchar, int endchar); -extern void SwigScanner_set_location(SwigScanner *, DOHString *file, int line); -extern DOHString *SwigScanner_get_file(SwigScanner *); +extern void SwigScanner_set_location(SwigScanner *, String *file, int line); +extern String *SwigScanner_get_file(SwigScanner *); extern int SwigScanner_get_line(SwigScanner *); extern void SwigScanner_idstart(SwigScanner *, char *idchar); @@ -227,43 +144,72 @@ extern void SwigScanner_idstart(SwigScanner *, char *idchar); #define SWIG_TOKEN_LAST 99 /* --- Functions for manipulating the string-based type encoding --- */ +typedef DOH SwigType; -extern void SwigType_add_pointer(DOHString *t); -extern void SwigType_add_array(DOHString *t, DOHString_or_char *size); -extern void SwigType_add_reference(DOHString *t); -extern void SwigType_add_qualifier(DOHString *t, DOHString_or_char *qual); -extern void SwigType_add_function(DOHString *t, DOHList *parms); -extern DOHList *SwigType_split(DOHString *t); -extern DOHString *SwigType_pop(DOHString *t); -extern void SwigType_push(DOHString *t, DOHString *s); -extern DOHList *SwigType_parmlist(DOHString *p); -extern DOHString *SwigType_parm(DOHString *p); -extern DOHString *SwigType_str(DOHString *s, DOHString_or_char *id); -extern DOHString *SwigType_lstr(DOHString *s, DOHString_or_char *id); -extern DOHString *SwigType_rcaststr(DOHString *s, DOHString_or_char *id); -extern DOHString *SwigType_lcaststr(DOHString *s, DOHString_or_char *id); -extern int SwigType_ispointer(DOHString_or_char *t); -extern int SwigType_isreference(DOHString_or_char *t); -extern int SwigType_isarray(DOHString_or_char *t); -extern int SwigType_isfunction(DOHString_or_char *t); -extern int SwigType_isqualifier(DOHString_or_char *t); -extern DOHString *SwigType_base(DOHString_or_char *t); -extern DOHString *SwigType_prefix(DOHString_or_char *t); +extern SwigType *NewSwigType(int typecode); +extern void SwigType_add_pointer(SwigType *t); +extern void SwigType_del_pointer(SwigType *t); +extern void SwigType_add_array(SwigType *t, String_or_char *size); +extern void SwigType_add_reference(SwigType *t); +extern void SwigType_add_qualifier(SwigType *t, String_or_char *qual); +extern void SwigType_add_function(SwigType *t, List *parms); +extern List *SwigType_split(SwigType *t); +extern String *SwigType_pop(SwigType *t); +extern void SwigType_push(SwigType *t, SwigType *s); +extern List *SwigType_parmlist(SwigType *p); +extern String *SwigType_parm(String *p); +extern String *SwigType_str(SwigType *s, String_or_char *id); +extern String *SwigType_lstr(SwigType *s, String_or_char *id); +extern String *SwigType_rcaststr(SwigType *s, String_or_char *id); +extern String *SwigType_lcaststr(SwigType *s, String_or_char *id); +extern String *SwigType_manglestr(SwigType *t); +extern SwigType *SwigType_ltype(SwigType *t); +extern int SwigType_ispointer(SwigType *t); +extern int SwigType_isreference(SwigType *t); +extern int SwigType_isarray(SwigType *t); +extern int SwigType_isfunction(SwigType *t); +extern int SwigType_isqualifier(SwigType *t); +extern int SwigType_isconst(SwigType *t); -extern int SwigType_typedef(DOHString_or_char *type, DOHString_or_char *name); +extern String *SwigType_base(SwigType *t); +extern String *SwigType_prefix(SwigType *t); +extern void SwigType_setbase(SwigType *t, String_or_char *name); + +extern int SwigType_typedef(SwigType *type, String_or_char *name); +extern void SwigType_inherit(String *subclass, String *baseclass); extern void SwigType_new_scope(); extern void SwigType_reset_scopes(); -extern void SwigType_set_scope_name(DOHString_or_char *name); -extern void SwigType_merge_scope(DOHHash *scope, DOHString_or_char *prefix); -extern DOHHash *SwigType_pop_scope(); -extern DOHString *SwigType_typedef_resolve(DOHString_or_char *t); -extern int SwigType_istypedef(DOHString_or_char *t); -extern int SwigType_cmp(DOHString_or_char *pat, DOHString_or_char *t); -extern int SwigType_array_ndim(DOHString_or_char *t); -extern DOHString *SwigType_array_getdim(DOHString_or_char *t, int n); -extern void SwigType_array_setdim(DOHString_or_char *t, int n, DOHString_or_char *rep); -extern DOHString *SwigType_default(DOHString_or_char *t); +extern void SwigType_set_scope_name(String_or_char *name); +extern void SwigType_merge_scope(Hash *scope, String_or_char *prefix); +extern Hash *SwigType_pop_scope(); +extern String *SwigType_typedef_resolve(SwigType *t); +extern int SwigType_istypedef(SwigType *t); +extern int SwigType_cmp(String_or_char *pat, SwigType *t); +extern int SwigType_array_ndim(SwigType *t); +extern String *SwigType_array_getdim(SwigType *t, int n); +extern void SwigType_array_setdim(SwigType *t, int n, String_or_char *rep); +extern String *SwigType_default(SwigType *t); +extern int SwigType_type(SwigType *t); +extern void SwigType_remember(SwigType *t); +extern void SwigType_emit_type_table(File *f_headers, File *f_table); +/* --- Parameters and Parameter Lists --- */ + +/* Parameters are really just hidden behind a DOH object. The following + interface will probably be simplified even further. */ + +typedef DOH Parm; + +extern Parm *NewParm(SwigType *type, String_or_char *n); +extern Parm *CopyParm(Parm *p); + +typedef DOH ParmList; + +extern ParmList *CopyParmList(ParmList *); +extern int ParmList_len(ParmList *); +extern int ParmList_numarg(ParmList *); +extern String *ParmList_str(ParmList *); +extern String *ParmList_protostr(ParmList *); /* --- Parse tree support --- */ @@ -273,7 +219,7 @@ typedef struct { } SwigRule; extern void Swig_dump_tags(DOH *obj, DOH *root); -extern void Swig_add_rule(DOHString_or_char *, int (*action)(DOH *, void *)); +extern void Swig_add_rule(String_or_char *, int (*action)(DOH *, void *)); extern void Swig_add_rules(SwigRule ruleset[]); extern void Swig_clear_rules(); extern int Swig_emit(DOH *obj, void *clientdata); @@ -284,125 +230,126 @@ extern DOH *Swig_prev(DOH *obj); /* -- Wrapper function Object */ typedef struct { - DataType *_type; + SwigType *_type; ParmList *_parms; - DOHString *_name; - DOHHash *localh; - DOHString *def; - DOHString *locals; - DOHString *code; + String *_name; + Hash *localh; + String *def; + String *locals; + String *code; } Wrapper; extern Wrapper *NewWrapper(); extern void DelWrapper(Wrapper *w); -extern void Wrapper_print(Wrapper *w, DOHFile *f); -extern int Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl); -extern int Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...); -extern int Wrapper_check_local(Wrapper *w, const DOHString_or_char *name); -extern char *Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl); -extern char *Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...); -extern DataType *Wrapper_Gettype(Wrapper *w); -extern void Wrapper_Settype(Wrapper *w, DataType *t); +extern void Wrapper_print(Wrapper *w, File *f); +extern int Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl); +extern int Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...); +extern int Wrapper_check_local(Wrapper *w, const String_or_char *name); +extern char *Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl); +extern char *Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...); +extern SwigType *Wrapper_Gettype(Wrapper *w); +extern void Wrapper_Settype(Wrapper *w, SwigType *t); extern ParmList *Wrapper_Getparms(Wrapper *w); extern void Wrapper_Setparms(Wrapper *w, ParmList *l); extern char *Wrapper_Getname(Wrapper *w); -extern void Wrapper_Setname(Wrapper *w, DOHString_or_char *name); +extern void Wrapper_Setname(Wrapper *w, String_or_char *name); /* --- Naming functions --- */ -extern void Swig_name_register(DOHString_or_char *method, DOHString_or_char *format); -extern char *Swig_name_mangle(DOHString_or_char *s); -extern char *Swig_name_wrapper(DOHString_or_char *fname); -extern char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname); -extern char *Swig_name_get(DOHString_or_char *vname); -extern char *Swig_name_set(DOHString_or_char *vname); -extern char *Swig_name_construct(DOHString_or_char *classname); -extern char *Swig_name_destroy(DOHString_or_char *classname); +extern void Swig_name_register(String_or_char *method, String_or_char *format); +extern String *Swig_name_mangle(String_or_char *s); +extern String *Swig_name_wrapper(String_or_char *fname); +extern String *Swig_name_member(String_or_char *classname, String_or_char *mname); +extern String *Swig_name_get(String_or_char *vname); +extern String *Swig_name_set(String_or_char *vname); +extern String *Swig_name_construct(String_or_char *classname); +extern String *Swig_name_destroy(String_or_char *classname); /* --- Mapping interface --- */ -extern void Swig_map_add(DOHHash *ruleset, DOHHash *parms, DOH *obj); -extern DOH *Swig_map_match(DOHHash *ruleset, DOHHash *parms, int *nmatch); +extern void Swig_map_add(Hash *ruleset, Hash *parms, DOH *obj); +extern DOH *Swig_map_match(Hash *ruleset, Hash *parms, int *nmatch); /* --- Misc --- */ -extern char *Swig_copy_string(const char *c); -extern void Swig_banner(DOHFile *f); +extern char *Swig_copy_string(const char *c); +extern void Swig_banner(File *f); +extern DOH *Swig_temp_result(DOH *x); /* --- C Wrappers --- */ -extern char *Swig_clocal(DataType *t, DOHString_or_char *name, DOHString_or_char *value); -extern DataType *Swig_clocal_type(DataType *t); -extern char *Swig_clocal_deref(DataType *t, DOHString_or_char *name); -extern char *Swig_clocal_assign(DataType *t, DOHString_or_char *name); -extern char *Swig_cparm_name(Parm *p, int i); +extern String *Swig_clocal(SwigType *t, String_or_char *name, String_or_char *value); +extern SwigType *Swig_clocal_type(SwigType *t); +extern String *Swig_clocal_deref(SwigType *t, String_or_char *name); +extern String *Swig_clocal_assign(SwigType *t, String_or_char *name); +extern String *Swig_cparm_name(Parm *p, int i); extern int Swig_cargs(Wrapper *w, ParmList *l); -extern void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl); -extern void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl); -extern char *Swig_cfunction_call(DOHString_or_char *name, ParmList *parms); -extern char *Swig_cmethod_call(DOHString_or_char *name, ParmList *parms); -extern char *Swig_cconstructor_call(DOHString_or_char *name); -extern char *Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms); -extern char *Swig_cdestructor_call(); -extern char *Swig_cppdestructor_call(); -extern char *Swig_cmemberset_call(DOHString_or_char *name, DataType *t); -extern char *Swig_cmemberget_call(DOHString_or_char *name, DataType *t); +extern void Swig_cresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl); +extern void Swig_cppresult(Wrapper *w, SwigType *t, String_or_char *name, String_or_char *decl); +extern String *Swig_cfunction_call(String_or_char *name, ParmList *parms); +extern String *Swig_cmethod_call(String_or_char *name, ParmList *parms); +extern String *Swig_cconstructor_call(String_or_char *name); +extern String *Swig_cppconstructor_call(String_or_char *name, ParmList *parms); +extern String *Swig_cdestructor_call(); +extern String *Swig_cppdestructor_call(); +extern String *Swig_cmemberset_call(String_or_char *name, SwigType *t); +extern String *Swig_cmemberget_call(String_or_char *name, SwigType *t); -extern Wrapper *Swig_cfunction_wrapper(DOHString_or_char *funcname, - DataType *rtype, +extern Wrapper *Swig_cfunction_wrapper(String_or_char *funcname, + SwigType *rtype, ParmList *parms, - DOHString_or_char *code); + String_or_char *code); -extern Wrapper *Swig_cmethod_wrapper(DOHString_or_char *classname, - DOHString_or_char *methodname, - DataType *rtype, +extern Wrapper *Swig_cmethod_wrapper(String_or_char *classname, + String_or_char *methodname, + SwigType *rtype, ParmList *parms, - DOHString_or_char *code); + String_or_char *code); -extern Wrapper *Swig_cdestructor_wrapper(DOHString_or_char *classname, - DOHString_or_char *code); +extern Wrapper *Swig_cdestructor_wrapper(String_or_char *classname, + String_or_char *code); -extern Wrapper *Swig_cppdestructor_wrapper(DOHString_or_char *classname, - DOHString_or_char *code); +extern Wrapper *Swig_cppdestructor_wrapper(String_or_char *classname, + String_or_char *code); -extern Wrapper *Swig_cconstructor_wrapper(DOHString_or_char *classname, +extern Wrapper *Swig_cconstructor_wrapper(String_or_char *classname, ParmList *parms, - DOHString_or_char *code); + String_or_char *code); -extern Wrapper *Swig_cppconstructor_wrapper(DOHString_or_char *classname, +extern Wrapper *Swig_cppconstructor_wrapper(String_or_char *classname, ParmList *parms, - DOHString_or_char *code); + String_or_char *code); -extern Wrapper *Swig_cmemberset_wrapper(DOHString_or_char *classname, - DOHString_or_char *membername, - DataType *type, - DOHString_or_char *code); +extern Wrapper *Swig_cmemberset_wrapper(String_or_char *classname, + String_or_char *membername, + SwigType *type, + String_or_char *code); -extern Wrapper *Swig_cmemberget_wrapper(DOHString_or_char *classname, - DOHString_or_char *membername, - DataType *type, - DOHString_or_char *code); +extern Wrapper *Swig_cmemberget_wrapper(String_or_char *classname, + String_or_char *membername, + SwigType *type, + String_or_char *code); -extern Wrapper *Swig_cvarset_wrapper(DOHString_or_char *varname, - DataType *type, - DOHString_or_char *code); +extern Wrapper *Swig_cvarset_wrapper(String_or_char *varname, + SwigType *type, + String_or_char *code); -extern Wrapper *Swig_cvarget_wrapper(DOHString_or_char *varname, - DataType *type, - DOHString_or_char *code); +extern Wrapper *Swig_cvarget_wrapper(String_or_char *varname, + SwigType *type, + String_or_char *code); /* --- Attribute access macros --- */ -#define Gettype(x) ((DataType *) GetVoid(x,"type")) -#define Getname(x) GetChar(x,"name") -#define Getvalue(x) GetChar(x,"value") -#define Getlname(x) GetChar(x,"lname") +#define Gettype(x) Getattr(x,"type") +#define Getname(x) Getattr(x,"name") +#define Getvalue(x) Getattr(x,"value") +#define Getlname(x) Getattr(x,"lname") #define Getignore(x) GetInt(x,"ignore") -#define Settype(x,v) Setattr(x,"type",NewVoid(CopyDataType(v), (void (*)(void *)) DelDataType)); -#define Setname(x,v) SetChar(x,"name",Char(v)) -#define Setlname(x,v) SetChar(x,"lname",Char(v)) -#define Setvalue(x,v) SetChar(x,"value", Char(v)) +#define Settype(x,v) Setattr(x,"type",x) +#define Setname(x,v) Setattr(x,"name",v) +#define Setlname(x,v) Setattr(x,"lname",v) +#define Setvalue(x,v) Setattr(x,"value", v) #define Setignore(x,v) SetInt(x,"ignore",v) #define Getnext(x) Getattr(x,"next") diff --git a/Source/Swig/tree.c b/Source/Swig/tree.c index 6bcbde549..1c5a19fa4 100644 --- a/Source/Swig/tree.c +++ b/Source/Swig/tree.c @@ -14,7 +14,7 @@ static char cvsroot[] = "$Header$"; -static DOHHash *rules = 0; +static Hash *rules = 0; /* ----------------------------------------------------------------------------- * Swig_next() @@ -66,7 +66,7 @@ Swig_dump_tags(DOH *obj, DOH *root) { * ----------------------------------------------------------------------------- */ void -Swig_add_rule(DOHString_or_char *name, int (*action)(DOH *node, void *clientdata)) +Swig_add_rule(String_or_char *name, int (*action)(DOH *node, void *clientdata)) { if (!rules) rules = NewHash(); if (action) diff --git a/Source/Swig/wrapfunc.c b/Source/Swig/wrapfunc.c index 7071e7d94..a74060249 100644 --- a/Source/Swig/wrapfunc.c +++ b/Source/Swig/wrapfunc.c @@ -51,7 +51,7 @@ DelWrapper(Wrapper *w) { Delete(w->locals); Delete(w->code); Delete(w->def); - if (w->_type) DelDataType(w->_type); + Delete(w->_type); Delete(w->_parms); Delete(w->_name); free(w); @@ -64,8 +64,8 @@ DelWrapper(Wrapper *w) { * ----------------------------------------------------------------------------- */ void -Wrapper_pretty_print(DOHString *str, DOHFile *f) { - DOHString *ts; +Wrapper_pretty_print(String *str, File *f) { + String *ts; int level = 0; int c, i; int empty = 1; @@ -124,8 +124,8 @@ Wrapper_pretty_print(DOHString *str, DOHFile *f) { * ----------------------------------------------------------------------------- */ void -Wrapper_print(Wrapper *w, DOHFile *f) { - DOHString *str; +Wrapper_print(Wrapper *w, File *f) { + String *str; str = NewString(""); Printf(str,"%s\n", w->def); @@ -142,7 +142,7 @@ Wrapper_print(Wrapper *w, DOHFile *f) { * ----------------------------------------------------------------------------- */ int -Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl) { +Wrapper_add_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) { /* See if the local has already been declared */ if (Getattr(w->localh,name)) { return -1; @@ -161,10 +161,10 @@ Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_ * ----------------------------------------------------------------------------- */ int -Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...) { +Wrapper_add_localv(Wrapper *w, const String_or_char *name, ...) { va_list ap; int ret; - DOHString *decl; + String *decl; DOH *obj; decl = NewString(""); va_start(ap,name); @@ -189,7 +189,7 @@ Wrapper_add_localv(Wrapper *w, const DOHString_or_char *name, ...) { * ----------------------------------------------------------------------------- */ int -Wrapper_check_local(Wrapper *w, const DOHString_or_char *name) { +Wrapper_check_local(Wrapper *w, const String_or_char *name) { if (Getattr(w->localh,name)) { return 1; } @@ -204,10 +204,10 @@ Wrapper_check_local(Wrapper *w, const DOHString_or_char *name) { * ----------------------------------------------------------------------------- */ char * -Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_char *decl) { +Wrapper_new_local(Wrapper *w, const String_or_char *name, const String_or_char *decl) { int i; - DOHString *nname = NewString(name); - DOHString *ndecl = NewString(decl); + String *nname = NewString(name); + String *ndecl = NewString(decl); char *ret; i = 0; @@ -236,10 +236,10 @@ Wrapper_new_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_ * ----------------------------------------------------------------------------- */ char * -Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) { +Wrapper_new_localv(Wrapper *w, const String_or_char *name, ...) { va_list ap; char *ret; - DOHString *decl; + String *decl; DOH *obj; decl = NewString(""); va_start(ap,name); @@ -261,7 +261,7 @@ Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) { * Wrapper_Gettype() * ----------------------------------------------------------------------------- */ -DataType * +SwigType * Wrapper_Gettype(Wrapper *w) { return w->_type; } @@ -271,9 +271,9 @@ Wrapper_Gettype(Wrapper *w) { * ----------------------------------------------------------------------------- */ void -Wrapper_Settype(Wrapper *w, DataType *t) { - if (w->_type) DelDataType(w->_type); - w->_type = CopyDataType(t); +Wrapper_Settype(Wrapper *w, SwigType *t) { + Delete(w->_type); + w->_type = Copy(t); } /* ----------------------------------------------------------------------------- @@ -310,9 +310,13 @@ Wrapper_Getname(Wrapper *w) { * ----------------------------------------------------------------------------- */ void -Wrapper_Setname(Wrapper *w, DOHString_or_char *n) { +Wrapper_Setname(Wrapper *w, String_or_char *n) { Delete(w->_name); w->_name = NewString(n); } + + + +