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