diff --git a/SWIG/Source/Swig/cwrap.c b/SWIG/Source/Swig/cwrap.c
index 0c37e6ec4..ef903ae98 100644
--- a/SWIG/Source/Swig/cwrap.c
+++ b/SWIG/Source/Swig/cwrap.c
@@ -27,8 +27,12 @@ char *
 Swig_cparm_name(Parm *p, int i) {
   static char name[256];
   sprintf(name,"arg%d",i);
-  Parm_Setlname(p,name);
-  return Parm_Getlname(p);
+  if (p) {
+    Parm_Setlname(p,name);
+    return Parm_Getlname(p);
+  } else {
+    return name;
+  }
 }
 
 /* -----------------------------------------------------------------------------
@@ -174,10 +178,7 @@ int Swig_cargs(Wrapper *w, ParmList *l) {
  * ----------------------------------------------------------------------------- */
 
 void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
-  int  i;
-  Parm  *p;
   DOHString *fcall;
-  char *tm;
 
   fcall = NewString("");
   if ((t->type != T_VOID) || (t->is_pointer)) {
@@ -224,10 +225,7 @@ void Swig_cresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or
  * ----------------------------------------------------------------------------- */
 
 void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *decl) {
-  int  i;
-  Parm  *p;
   DOHString *fcall;
-  char *tm;
 
   fcall = NewString("");
   if ((t->type != T_VOID) || (t->is_pointer)) {
@@ -240,7 +238,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
 	Printv(fcall, DataType_str(t,"_result_ref")," = ", 0);
       } else {
 	/* Normal return value */
-	Printv(fcall, name, " = (", DataType_lstr(t,0), ")", 0);
+	Printv(fcall, name, " = ", DataType_lcaststr(t,""), 0);
       }
     }
   }
@@ -264,7 +262,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
 }
 
 /* -----------------------------------------------------------------------------
- * Swig_cfunction()
+ * Swig_cfunction_call()
  *
  * Creates a string that calls a C function using the local variable rules
  * defined above.
@@ -274,7 +272,7 @@ void Swig_cppresult(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_
  * ----------------------------------------------------------------------------- */
 
 char *
-Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
+Swig_cfunction_call(DOHString_or_char *name, ParmList *parms) {
   static DOH *func = 0;
   int i = 0;
   Parm *p;
@@ -299,7 +297,7 @@ Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
 }
 
 /* -----------------------------------------------------------------------------
- * Swig_cmethod()
+ * Swig_cmethod_call()
  *
  * Generates a string that calls a C++ method from a list of parameters.
  * 
@@ -308,7 +306,7 @@ Swig_cfunction(DOHString_or_char *name, ParmList *parms) {
  * ----------------------------------------------------------------------------- */
 
 char *
-Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
+Swig_cmethod_call(DOHString_or_char *name, ParmList *parms) {
   static DOH *func = 0;
   int i = 0;
   Parm *p;
@@ -336,7 +334,100 @@ Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
 }
 
 /* -----------------------------------------------------------------------------
- * Swig_cmember_set()
+ * Swig_cconstructor_call()
+ *
+ * Creates a string that calls a C constructor function.
+ *
+ *      (name *) calloc(1,sizeof(name));
+ * ----------------------------------------------------------------------------- */
+
+char *
+Swig_cconstructor_call(DOHString_or_char *name) {
+  static DOH *func = 0;
+
+  if (!func) func = NewString("");
+  Clear(func);
+
+  Printf(func,"(%s *) calloc(1, sizeof(%s))", name, name);
+  return Char(func);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cppconstructor_call()
+ *
+ * Creates a string that calls a C function using the local variable rules
+ * defined above.
+ *
+ *    name(arg0, arg1, arg2, ... argn)
+ *
+ * ----------------------------------------------------------------------------- */
+
+char *
+Swig_cppconstructor_call(DOHString_or_char *name, ParmList *parms) {
+  static DOH *func = 0;
+  int i = 0;
+  Parm *p;
+  DataType *pt;
+  if (!func) func = NewString("");
+  Clear(func);
+
+  Printf(func,"new %s(", name);
+  p = ParmList_first(parms);
+  while (p) {
+    pt = Parm_Gettype(p);
+    Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,i)));
+    i++;
+    p = ParmList_next(parms);
+    if (p) 
+      Printf(func,",");
+  }
+  Printf(func,")");
+  return Char(func);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cdestructor_call()
+ *
+ * Creates a string that calls a C constructor function.
+ *
+ *      free((char *) arg0);
+ * ----------------------------------------------------------------------------- */
+
+char *
+Swig_cdestructor_call() {
+  static DOH *func = 0;
+
+  if (!func) func = NewString("");
+  Clear(func);
+
+  Printf(func,"free((char *) %s)", Swig_cparm_name(0,0));
+  return Char(func);
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cppdestructor_call()
+ *
+ * Creates a string that calls a C constructor function.
+ *
+ *      delete arg0;
+ * ----------------------------------------------------------------------------- */
+
+char *
+Swig_cppdestructor_call() {
+  static DOH *func = 0;
+
+  if (!func) func = NewString("");
+  Clear(func);
+
+  Printf(func,"delete %s", Swig_cparm_name(0,0));
+  return Char(func);
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_cmemberset_call()
  *
  * Generates a string that sets the name of a member in a C++ class or C struct.
  *
@@ -345,31 +436,25 @@ Swig_cmethod(DOHString_or_char *name, ParmList *parms) {
  * ----------------------------------------------------------------------------- */
 
 char *
-Swig_cmember_set(DOHString_or_char *name, ParmList *parms) {
+Swig_cmemberset_call(DOHString_or_char *name, DataType *type) {
   static DOH *func = 0;
-  Parm *p;
-  DataType *pt;
 
   if (!func) func = NewString("");
   Clear(func);
 
-  if (ParmList_numarg(parms) != 2) {
-    printf("Swig_cmember_set called with wrong # args!\n");
-    abort();
+  if ((type->type == T_USER) && (type->is_pointer == 0)) {
+    Printf(func,"%s %s->%s; ", Swig_clocal_assign(type,""), Swig_cparm_name(0,0), name);
+  } else {
+    Printf(func,"%s ", Swig_clocal_assign(type,""));
   }
-
-  p = ParmList_first(parms);
-  Printf(func,"(%s->%s = ", Swig_cparm_name(p,0), name);
-  p = ParmList_next(parms);
-  pt = Parm_Gettype(p);
-  Printf(func,"%s", Swig_clocal_deref(pt, Swig_cparm_name(p,1)));
-  Printf(func,")");
+  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);
 }
 
 
 /* -----------------------------------------------------------------------------
- * Swig_cmember_get()
+ * Swig_cmemberget_call()
  *
  * Generates a string that sets the name of a member in a C++ class or C struct.
  *
@@ -378,28 +463,535 @@ Swig_cmember_set(DOHString_or_char *name, ParmList *parms) {
  * ----------------------------------------------------------------------------- */
 
 char *
-Swig_cmember_get(DOHString_or_char *name, ParmList *parms) {
+Swig_cmemberget_call(DOHString_or_char *name, DataType *t) {
   static DOH *func = 0;
-  Parm *p;
-  DataType *pt;
 
   if (!func) func = NewString("");
   Clear(func);
 
-  if (ParmList_numarg(parms) != 1) {
-    printf("Swig_cmember_get called with wrong # args!\n");
-    abort();
-  }
-
-  p = ParmList_first(parms);
-  Printf(func,"(%s->%s)", Swig_cparm_name(p,0), name);
+  Printf(func,"%s (%s->%s)", Swig_clocal_assign(t,""),Swig_cparm_name(0,0), name);
   return Char(func);
 }
 
 
+static void fix_parm_names(ParmList *l) {
+  int i = 0;
+  Parm *p;
+
+  p = ParmList_first(l);
+  while (p) {
+    if (!Parm_Getname(p)) {
+      char temp[64];
+      sprintf(temp,"arg%d",i);
+      Parm_Setname(p,temp);
+    }
+    i++;
+    p = ParmList_next(l);
+  }
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_cfunction_wrapper()
+ *
+ * This function creates a C wrapper around a C++ method.  Returns a Wrapper
+ * object containing the code, parameters, and so forth.
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cfunction_wrapper(DOHString_or_char *funcname,
+		       DataType *rtype,
+		       ParmList *parms,
+		       DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,funcname);
+
+  l = CopyParmList(parms);
+
+  fix_parm_names(l);
+
+  Printf(w->def,"%s %s(%s)", DataType_str(rtype,0), funcname, ParmList_str(l));
+
+  if (code) {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,rtype);
+  Wrapper_Setparms(w,l);
+
+  DelParmList(l);
+  return w;
+}
+  
+/* -----------------------------------------------------------------------------
+ * Swig_cmethod_wrapper()
+ *
+ * This function creates a C wrapper around a C++ method.  Returns a Wrapper
+ * object containing the code, parameters, and so forth.
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cmethod_wrapper(DOHString_or_char *classname,
+		     DOHString_or_char *methodname,
+		     DataType *rtype,
+		     ParmList *parms,
+		     DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  Parm     *p;
+  DataType *t;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_member(classname, methodname));
+
+  l = CopyParmList(parms);
+  t = NewDataType(T_USER);
+  strcpy(t->name,Char(classname));
+  t->is_pointer++;
+  p = NewParm(t,"self");
+  ParmList_insert(l,p,0);
+  DelDataType(t);
+  DelParm(p);
+
+  fix_parm_names(l);
+
+  Printf(w->def,"%s %s(%s)", DataType_str(rtype,0), Swig_name_member(classname, methodname), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    
+    if ((rtype->type != T_VOID) || (rtype->is_pointer)) {
+      Printf(w->code,"return ");
+    }
+    
+    Printf(w->code,"self->%s(", methodname);
+    p = ParmList_first(l);
+    p = ParmList_next(l);
+    while (p) {
+      Printf(w->code,"%s", Parm_Getname(p));
+      p = ParmList_next(l);
+      if (p) 
+	Printf(w->code,",");
+    }
+    Printf(w->code,");\n");
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,rtype);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  return w;
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cconstructor_wrapper()
+ *
+ * This function creates a C wrapper for a C constructor function. 
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cconstructor_wrapper(DOHString_or_char *classname,
+			  ParmList *parms,
+			  DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  DataType *t;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_construct(classname));
+
+  l = CopyParmList(parms);
+  t = NewDataType(T_USER);
+  sprintf(t->name,classname);
+  t->is_pointer++;
+
+  /* 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));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"return (%s) calloc(1,sizeof(%s));\n", DataType_str(t,0), classname);
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,t);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(t);
+  return w;
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cppconstructor_wrapper()
+ *
+ * This function creates a C wrapper for a C++ constructor function. 
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cppconstructor_wrapper(DOHString_or_char *classname,
+			  ParmList *parms,
+			  DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  DataType *t;
+  Parm     *p;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_construct(classname));
+
+  l = CopyParmList(parms);
+  t = NewDataType(T_USER);
+  sprintf(t->name,classname);
+  t->is_pointer++;
+
+  /* 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));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"return new %s", DataType_str(t,0));
+    p = ParmList_first(l);
+    if (p) {
+      Printf(w->code,"(");
+      while (p) {
+	Printf(w->code,"%s", Parm_Getname(p));
+	p = ParmList_next(l);
+	if (p)
+	  Printf(w->code,",");
+      }
+      Printf(w->code,")");
+    }
+    Printf(w->code,";\n");
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,t);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(t);
+  return w;
+}
+  
+
+/* -----------------------------------------------------------------------------
+ * Swig_cdestructor_wrapper()
+ *
+ * This function creates a C wrapper for a C destructor. 
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cdestructor_wrapper(DOHString_or_char *classname,
+			  DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  DataType *t;
+  Parm     *p;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_destroy(classname));
+
+  l = NewParmList();
+  t = NewDataType(T_USER);
+  sprintf(t->name,classname);
+  t->is_pointer++;
+  p = NewParm(t,"self");
+  ParmList_append(l,p);
+  DelParm(p);
+  DelDataType(t);
+
+  t = NewDataType(T_VOID);
+
+  Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"free((char *) self);\n");
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,t);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(t);
+  return w;
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cppdestructor_wrapper()
+ *
+ * This function creates a C wrapper for a C++ destructor. 
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cppdestructor_wrapper(DOHString_or_char *classname,
+			  DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  DataType *t;
+  Parm     *p;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_destroy(classname));
+
+  l = NewParmList();
+  t = NewDataType(T_USER);
+  sprintf(t->name,classname);
+  t->is_pointer++;
+  p = NewParm(t,"self");
+  ParmList_append(l,p);
+  DelParm(p);
+  DelDataType(t);
+
+  t = NewDataType(T_VOID);
+
+  Printf(w->def,"%s %s(%s)", DataType_str(t,0), Swig_name_destroy(classname), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"delete self;\n");
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,t);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(t);
+  return w;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_cmemberset_wrapper()
+ *
+ * This function creates a C wrapper for setting a C++ structure member.
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cmemberset_wrapper(DOHString_or_char *classname,
+			DOHString_or_char *membername,
+			DataType *type,
+			DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  Parm     *p;
+  DataType *t;
+  DataType *lt;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_member(classname, Swig_name_set(membername)));
+
+  l = NewParmList();
+  t = NewDataType(T_USER);
+  strcpy(t->name,Char(classname));
+  t->is_pointer++;
+  p = NewParm(t,"self");
+  ParmList_append(l,p);
+  DelDataType(t);
+  DelParm(p);
+
+  lt = Swig_clocal_type(type);
+  p = NewParm(lt,"value");
+  ParmList_append(l,p);
+  DelParm(p);
+  
+  Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"self->%s = %s;\n", membername, Swig_clocal_deref(lt,"value"));
+    Printf(w->code,"return %s self->%s;\n", Swig_clocal_assign(lt,""), membername);
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,lt);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(lt);
+  return w;
+}
+
+
+/* -----------------------------------------------------------------------------
+ * Swig_cmemberget_wrapper()
+ *
+ * This function creates a C wrapper for getting a structure member
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cmemberget_wrapper(DOHString_or_char *classname,
+			DOHString_or_char *membername,
+			DataType *type,
+			DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  Parm     *p;
+  DataType *t;
+  DataType *lt;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_member(classname, Swig_name_get(membername)));
+
+  l = NewParmList();
+  t = NewDataType(T_USER);
+  strcpy(t->name,Char(classname));
+  t->is_pointer++;
+  p = NewParm(t,"self");
+  ParmList_append(l,p);
+  DelDataType(t);
+  DelParm(p);
+
+  lt = Swig_clocal_type(type);
+  Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"return %s self->%s;", Swig_clocal_assign(lt,""), membername);
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,lt);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(lt);
+  return w;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_cvarset_wrapper()
+ *
+ * This function creates a C wrapper for setting a global variable.
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cvarset_wrapper(DOHString_or_char *varname,
+		     DataType *type,
+		     DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  Parm     *p;
+  DataType *lt;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w,Swig_name_set(varname));
+
+  l = NewParmList();
+  lt = Swig_clocal_type(type);
+  p = NewParm(lt,"value");
+  ParmList_append(l,p);
+  DelParm(p);
+  
+  Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"%s = %s;\n", varname, Swig_clocal_deref(lt,"value"));
+    Printf(w->code,"return %s;\n", Swig_clocal_assign(lt,varname));
+    Printf(w->code,"}\n");
+  } else {
+    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);
+  }
+  Wrapper_Settype(w,lt);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(lt);
+  return w;
+}
+
+/* -----------------------------------------------------------------------------
+ * Swig_cvarget_wrapper()
+ *
+ * This function creates a C wrapper for getting a structure member
+ * ----------------------------------------------------------------------------- */
+
+Wrapper *
+Swig_cvarget_wrapper(DOHString_or_char *varname,
+                     DataType *type,
+                     DOHString_or_char *code)
+{
+  Wrapper *w;
+  ParmList *l;
+  DataType *lt;
+
+  w = NewWrapper();
+
+  /* Set the name of the function */
+  Wrapper_Setname(w, Swig_name_get(varname));
+
+  l = NewParmList();
+
+  lt = Swig_clocal_type(type);
+
+  Printf(w->def,"%s %s(%s)", DataType_str(lt,0), Wrapper_Getname(w), ParmList_str(l));
+
+  if (!code) {
+    /* No code supplied.  Write a function manually */
+    Printf(w->def," {\n");
+    Printf(w->code,"return %s;", Swig_clocal_assign(type,varname));
+    Printf(w->code,"}\n");
+  } else {
+    Printv(w->code, code, "\n", 0);
+  }
+  Wrapper_Settype(w,lt);
+  Wrapper_Setparms(w,l);
+  DelParmList(l);
+  DelDataType(lt);
+  return w;
+}
+
+
 
 
 
-
-
-
diff --git a/SWIG/Source/Swig/map.c b/SWIG/Source/Swig/map.c
index 411cb7659..7786ee415 100644
--- a/SWIG/Source/Swig/map.c
+++ b/SWIG/Source/Swig/map.c
@@ -10,6 +10,8 @@
  * See the file LICENSE for information on usage and redistribution.
  * ----------------------------------------------------------------------------- */
 
+static char cvsroot[] = "$Header$";
+
 #include "swig.h"
 
 /* -----------------------------------------------------------------------------
@@ -223,7 +225,7 @@ Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename, DOHHash *parms, in
          related to array indices */
 
       int ndim;
-      int i, j, k, n;
+      int i, j, n;
       int ncheck;
       DOHString  *ntype;
 
@@ -306,7 +308,7 @@ Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename, DOHHash *parms, in
   } else {
     /* If there is no match at all.  I guess we can check for a default type */
     DOH  *rs;
-    DOHString *key, *name;
+    DOHString *key;
     DOHString *dty = SwigType_default(Getattr(parms,"type"));
     key = NewStringf("-%s",dty);
     
diff --git a/SWIG/Source/Swig/naming.c b/SWIG/Source/Swig/naming.c
index f5c8be883..90ab9e56f 100644
--- a/SWIG/Source/Swig/naming.c
+++ b/SWIG/Source/Swig/naming.c
@@ -82,6 +82,7 @@ char *Swig_name_wrapper(DOHString_or_char *fname) {
 char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
   static DOHString *r = 0;
   DOHString *f;
+  char   *cname, *c;
 
   if (!r) r = NewString("");
   if (!naming_hash) naming_hash = NewHash();
@@ -92,7 +93,10 @@ char *Swig_name_member(DOHString_or_char *classname, DOHString_or_char *mname) {
   } else {
     Append(r,f);
   }
-  Replace(r,"%c",classname, DOH_REPLACE_ANY);
+  cname = Char(classname);
+  c = strchr(cname, ' ');
+  if (c) cname = c+1;
+  Replace(r,"%c",cname, DOH_REPLACE_ANY);
   Replace(r,"%m",mname, DOH_REPLACE_ANY);
   return Char(r);
 }
@@ -152,7 +156,7 @@ char *Swig_name_set(DOHString_or_char *vname) {
 char *Swig_name_construct(DOHString_or_char *classname) {
   static DOHString *r = 0;
   DOHString *f;
-
+  char *cname, *c;
   if (!r) r = NewString("");
   if (!naming_hash) naming_hash = NewHash();
   Clear(r);
@@ -162,7 +166,12 @@ char *Swig_name_construct(DOHString_or_char *classname) {
   } else {
     Append(r,f);
   }
-  Replace(r,"%c",classname, DOH_REPLACE_ANY);
+
+  cname = Char(classname);
+  c = strchr(cname, ' ');
+  if (c) cname = c+1;
+
+  Replace(r,"%c",cname, DOH_REPLACE_ANY);
   return Char(r);
 }
   
@@ -176,7 +185,7 @@ char *Swig_name_construct(DOHString_or_char *classname) {
 char *Swig_name_destroy(DOHString_or_char *classname) {
   static DOHString *r = 0;
   DOHString *f;
-
+  char *cname, *c;
   if (!r) r = NewString("");
   if (!naming_hash) naming_hash = NewHash();
   Clear(r);
@@ -186,6 +195,14 @@ char *Swig_name_destroy(DOHString_or_char *classname) {
   } else {
     Append(r,f);
   }
-  Replace(r,"%c",classname, DOH_REPLACE_ANY);
+
+  cname = Char(classname);
+  c = strchr(cname, ' ');
+  if (c) cname = c+1;
+
+  Replace(r,"%c",cname, DOH_REPLACE_ANY);
   return Char(r);
 }
+
+
+
diff --git a/SWIG/Source/Swig/oldparms.c b/SWIG/Source/Swig/oldparms.c
index d30a917e5..05aafd4b8 100644
--- a/SWIG/Source/Swig/oldparms.c
+++ b/SWIG/Source/Swig/oldparms.c
@@ -36,7 +36,7 @@ Parm *NewParm(DataType *type, char *n) {
   p->_name = Swig_copy_string(n);
   p->_lname = 0;
   p->_defvalue = 0;
-  p->ignore = 0;
+  p->_ignore = 0;
   return p;
 }
 
@@ -50,7 +50,7 @@ Parm *CopyParm(Parm *p) {
   np->_name = Swig_copy_string(p->_name);
   np->_defvalue = Swig_copy_string(p->_defvalue);
   np->_lname = Swig_copy_string(p->_lname);
-  np->ignore = p->ignore;
+  np->_ignore = p->_ignore;
   return np;
 }
 
@@ -102,6 +102,14 @@ char *Parm_Getvalue(Parm *p) {
   return p->_defvalue;
 }
 
+int Parm_Getignore(Parm *p) {
+  return p->_ignore;
+}
+
+void Parm_Setignore(Parm *p, int i) {
+  p->_ignore = i;
+}
+
 /* ------------------------------------------------------------------
  * NewParmList()
  * ------------------------------------------------------------------ */
@@ -259,7 +267,7 @@ int ParmList_numarg(ParmList *l) {
   int  n = 0;
   int  i;
   for (i = 0; i < l->nparms; i++) {
-    if (!l->parms[i]->ignore)
+    if (!Parm_Getignore(l->parms[i]))
       n++;
   }
   return n;
@@ -293,7 +301,6 @@ Parm * ParmList_next(ParmList *l) {
 
 void ParmList_print_types(ParmList *l, DOHFile *f) {
 
-  int   is_pointer;
   int   pn;
   DataType *t;
   pn = 0;
@@ -313,7 +320,6 @@ void ParmList_print_types(ParmList *l, DOHFile *f) {
  * ---------------------------------------------------------------------- */
 
 void ParmList_print_args(ParmList *l, DOHFile *f) {
-  int   is_pointer;
   int   pn;
   DataType *t;
   pn = 0;
@@ -327,4 +333,29 @@ void ParmList_print_args(ParmList *l, DOHFile *f) {
 }
 
 
+/* ---------------------------------------------------------------------
+ * void ParmList_str()
+ *
+ * Generates a string of parameters
+ * ---------------------------------------------------------------------- */
+
+char *ParmList_str(ParmList *l) {
+  static DOHString *out = 0;
+  int   pn;
+  DataType *t;
+
+  if (!out) out = NewString("");
+  Clear(out);
+  pn = 0;
+  while(pn < l->nparms) {
+    t = Parm_Gettype(l->parms[pn]);
+    Printf(out,"%s", DataType_str(t,Parm_Getname(l->parms[pn])));
+    pn++;
+    if (pn < l->nparms)
+      Printf(out,",");
+  }
+  return Char(out);
+}
+
+
 
diff --git a/SWIG/Source/Swig/oldtypes.c b/SWIG/Source/Swig/oldtypes.c
index 388a2ed85..49c74f911 100644
--- a/SWIG/Source/Swig/oldtypes.c
+++ b/SWIG/Source/Swig/oldtypes.c
@@ -28,19 +28,19 @@ DataType *NewDataType(int t) {
   case T_BOOL:
     strcpy(ty->name,"bool");
     break;
-  case T_INT: case T_SINT:
+  case T_INT:
     strcpy(ty->name,"int");
     break;
   case T_UINT:
     strcpy(ty->name,"unsigned int");
     break;
-  case T_SHORT: case T_SSHORT:
+  case T_SHORT:
     strcpy(ty->name,"short");
     break;
   case T_USHORT:
     strcpy(ty->name,"unsigned short");
     break;
-  case T_LONG: case T_SLONG:
+  case T_LONG: 
     strcpy(ty->name,"long");
     break;
   case T_ULONG:
@@ -130,13 +130,13 @@ void DataType_primitive(DataType *t) {
   case T_BOOL:
     strcpy(t->name,"bool");
     break;
-  case T_INT: case T_SINT:
+  case T_INT:
     strcpy(t->name,"int");
     break;
-  case T_SHORT: case T_SSHORT:
+  case T_SHORT:
     strcpy(t->name,"short");
     break;
-  case T_LONG: case T_SLONG:
+  case T_LONG: 
     strcpy(t->name,"long");
     break;
   case T_CHAR: 
@@ -410,7 +410,6 @@ char *DataType_rcaststr(DataType *ty, DOHString_or_char *name) {
 char *DataType_lcaststr(DataType *ty, DOHString_or_char *name) {
   static char   result[8][256];
   static int    ri = 0;
-  DataType *t = 0;
   ri = ri % 8;
 
   strcpy(result[ri],"");
diff --git a/SWIG/Source/Swig/stype.c b/SWIG/Source/Swig/stype.c
index b85779e0a..9a909edaa 100644
--- a/SWIG/Source/Swig/stype.c
+++ b/SWIG/Source/Swig/stype.c
@@ -10,6 +10,8 @@
  * See the file LICENSE for information on usage and redistribution.
  * ----------------------------------------------------------------------------- */
 
+static char cvsroot[] = "$Header$";
+
 #include "swig.h"
 
 /* -----------------------------------------------------------------------------
@@ -244,7 +246,6 @@ void SwigType_push(DOHString *t, DOHString *cons)
   if (!cons) return;
   if (!Len(cons)) return;
   if (Len(t)) {
-    int len;
     char *c = Char(cons);
     if (c[strlen(c)-1] != '.')
       Insert(t,0,".");
@@ -534,10 +535,9 @@ DOHString *
 SwigType_cstr(DOHString *s, DOHString_or_char *id)
 {
   DOHString *result;
-  DOHString *element, *nextelement;
+  DOHString *element = 0, *nextelement;
   DOHList *elements;
   int nelements, i;
-  char *c;
 
   if (id) {
     result = NewString(Char(id));
@@ -616,7 +616,7 @@ static DOHHash   *scopes[MAX_SCOPE];            /* List representing the current
 static DOHString *scopenames[MAX_SCOPE];        /* Names of the various scopes         */
 static int      scope_level = 0;
 
-static init_scopes() {
+static void init_scopes() {
   if (type_scopes) return;
   type_scopes = NewHash();
   scopes[scope_level] = NewHash();
diff --git a/SWIG/Source/Swig/swig.h b/SWIG/Source/Swig/swig.h
index 4f6385bf0..5caed8e15 100644
--- a/SWIG/Source/Swig/swig.h
+++ b/SWIG/Source/Swig/swig.h
@@ -22,6 +22,129 @@
 
 #include "doh.h"
 
+/* --- 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_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);
+
+/* -- 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 */
+
+/* -- Old type interface -- */
+
+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
+
+/* --- Deprecated parameter list structure --- */
+
+typedef struct Parm {
+  DataType   *_type;            /* Datatype of this parameter   */
+  char       *_name;            /* Name of parameter (optional) */
+  char       *_defvalue;        /* Default value (as a string)  */
+  char       *_lname;           /* Local name                   */
+  int        _ignore;            /* Ignore flag                  */
+} Parm;
+
+extern Parm     *NewParm(DataType *type, char *n);
+extern Parm     *CopyParm(Parm *p);
+extern void      DelParm(Parm *p);
+extern void      Parm_Settype(Parm *p, DataType *t);
+extern DataType *Parm_Gettype(Parm *p);
+extern void      Parm_Setname(Parm *p, char *name);
+extern char     *Parm_Getname(Parm *p);
+extern void      Parm_Setlname(Parm *p, char *lname);
+extern char     *Parm_Getlname(Parm *p);
+extern void      Parm_Setvalue(Parm *p, char *value);
+extern char     *Parm_Getvalue(Parm *p);
+extern int       Parm_Getignore(Parm *p);
+extern void      Parm_Setignore(Parm *p, int i);
+
+typedef struct ParmList {
+  int     maxparms;               /* Max parms possible in current list  */
+  Parm  **parms;                  /* Pointer to parms array */
+  int     current_parm;           /* Internal state for get_first,get_next */
+  int     nparms;                 /* Number of parms in list */
+} ParmList;
+
+extern ParmList *NewParmList();
+extern ParmList *CopyParmList(ParmList *);
+extern void      DelParmList(ParmList *);
+extern Parm     *ParmList_get(ParmList *l, int pos);
+extern void      ParmList_append(ParmList *, Parm *);
+extern void      ParmList_insert(ParmList *, Parm *, int);
+extern void      ParmList_del(ParmList *, int);
+extern int       ParmList_numarg(ParmList *);
+extern Parm     *ParmList_first(ParmList *);
+extern Parm     *ParmList_next(ParmList *);
+extern void      ParmList_print_types(ParmList*,DOHFile *f);
+extern void      ParmList_print_args(ParmList *, DOHFile *f);
+extern char     *ParmList_str(ParmList *);
+
 /* --- File interface --- */
 
 extern void        Swig_add_directory(const DOHString_or_char *dirname);
@@ -170,20 +293,29 @@ extern DOH *Swig_prev(DOH *obj);
 /* -- Wrapper function Object */
 
 typedef struct {
+  DataType  *_type;
+  ParmList  *_parms;
+  DOHString *_name;
   DOHHash   *localh;
   DOHString *def;
   DOHString *locals;
   DOHString *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 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 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);
 
 /* --- Naming functions --- */
 
@@ -205,153 +337,71 @@ extern DOH        *Swig_map_match(DOHHash *ruleset, DOHString_or_char *rulename,
 extern char *Swig_copy_string(const char *c);
 extern void  Swig_banner(DOHFile *f);
 
-/* --- 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_SYMBOL    98
-#define    T_ERROR     99
-
-/* These types are now obsolete, but defined for backwards compatibility */
-
-#define    T_SINT      90
-#define    T_SSHORT    91
-#define    T_SLONG     92
-
-#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);
-
-/* -- 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 */
-
-/* -- Old type interface -- */
-
-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
-
-/* --- Deprecated parameter list structure */
-
-typedef struct Parm {
-  DataType   *_type;            /* Datatype of this parameter   */
-  char       *_name;            /* Name of parameter (optional) */
-  char       *_defvalue;        /* Default value (as a string)  */
-  char       *_lname;           /* Local name                   */
-  int        ignore;            /* Ignore flag                  */
-} Parm;
-
-extern Parm     *NewParm(DataType *type, char *n);
-extern Parm     *CopyParm(Parm *p);
-extern void      DelParm(Parm *p);
-extern void      Parm_Settype(Parm *p, DataType *t);
-extern DataType *Parm_Gettype(Parm *p);
-extern void      Parm_Setname(Parm *p, char *name);
-extern char     *Parm_Getname(Parm *p);
-extern void      Parm_Setlname(Parm *p, char *lname);
-extern char     *Parm_Getlname(Parm *p);
-extern void      Parm_Setvalue(Parm *p, char *value);
-extern char     *Parm_Getvalue(Parm *p);
-
-typedef struct ParmList {
-  int     maxparms;               /* Max parms possible in current list  */
-  Parm  **parms;                  /* Pointer to parms array */
-  int     current_parm;           /* Internal state for get_first,get_next */
-  int     nparms;                 /* Number of parms in list */
-} ParmList;
-
-extern ParmList *NewParmList();
-extern ParmList *CopyParmList(ParmList *);
-extern void      DelParmList(ParmList *);
-extern Parm     *ParmList_get(ParmList *l, int pos);
-extern void      ParmList_append(ParmList *, Parm *);
-extern void      ParmList_insert(ParmList *, Parm *, int);
-extern void      ParmList_del(ParmList *, int);
-extern int       ParmList_numarg(ParmList *);
-extern Parm     *ParmList_first(ParmList *);
-extern Parm     *ParmList_next(ParmList *);
-extern void      ParmList_print_types(ParmList*,DOHFile *f);
-extern void      ParmList_print_args(ParmList *, DOHFile *f);
-
-
-extern void     Wrapper_local(Wrapper *w, DataType *t, DOHString_or_char *name, DOHString_or_char *value);
-extern char    *Wrapper_local_deref(DataType *t, DOHString_or_char *name);
-
 /* --- 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 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(DOHString_or_char *name, ParmList *parms);
-extern char    *Swig_cmethod(DOHString_or_char *name, ParmList *parms);
-extern char    *Swig_cmember_set(DOHString_or_char *name, ParmList *parms);
-extern char    *Swig_cmember_get(DOHString_or_char *name, ParmList *parms);
+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 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 Wrapper   *Swig_cfunction_wrapper(DOHString_or_char *funcname,
+                                         DataType *rtype,
+                                         ParmList *parms,
+                                         DOHString_or_char *code);
+
+extern Wrapper   *Swig_cmethod_wrapper(DOHString_or_char *classname,
+				       DOHString_or_char *methodname,
+				       DataType *rtype,
+				       ParmList *parms,
+				       DOHString_or_char *code);
+
+extern Wrapper   *Swig_cdestructor_wrapper(DOHString_or_char *classname,
+                                           DOHString_or_char *code);
+
+extern Wrapper   *Swig_cppdestructor_wrapper(DOHString_or_char *classname,
+                                           DOHString_or_char *code);
+
+extern Wrapper   *Swig_cconstructor_wrapper(DOHString_or_char *classname,
+                                            ParmList *parms,
+                                            DOHString_or_char *code);
+
+extern Wrapper   *Swig_cppconstructor_wrapper(DOHString_or_char *classname,
+                                            ParmList *parms,
+                                            DOHString_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_cmemberget_wrapper(DOHString_or_char *classname,
+                                          DOHString_or_char *membername,
+					  DataType *type,
+                                          DOHString_or_char *code);
+
+extern Wrapper  *Swig_cvarset_wrapper(DOHString_or_char *varname,
+				      DataType *type,
+				      DOHString_or_char *code);
+
+extern Wrapper  *Swig_cvarget_wrapper(DOHString_or_char *varname,
+				      DataType *type,
+				      DOHString_or_char *code);
 
 #endif
 
 
 
 
+
diff --git a/SWIG/Source/Swig/wrapfunc.c b/SWIG/Source/Swig/wrapfunc.c
index ac5ffa680..c35c93e82 100644
--- a/SWIG/Source/Swig/wrapfunc.c
+++ b/SWIG/Source/Swig/wrapfunc.c
@@ -17,6 +17,7 @@
 static char cvsroot[] = "$Header$";
 
 #include "swig.h"
+#include <ctype.h>
 
 /* -----------------------------------------------------------------------------
  * NewWrapper()
@@ -32,6 +33,9 @@ NewWrapper() {
   w->locals = NewString("");
   w->code = NewString("");
   w->def = NewString("");
+  w->_type = 0;
+  w->_parms = 0;
+  w->_name = 0;
   return w;
 }
 
@@ -47,6 +51,9 @@ DelWrapper(Wrapper *w) {
   Delete(w->locals);
   Delete(w->code);
   Delete(w->def);
+  if (w->_type) DelDataType(w->_type);
+  if (w->_parms) DelParmList(w->_parms);
+  if (w->_name) Delete(w->_name);
   free(w);
 }
 
@@ -142,6 +149,7 @@ Wrapper_add_local(Wrapper *w, const DOHString_or_char *name, const DOHString_or_
   }
   Setattr(w->localh,name,decl);
   Printf(w->locals,"%s;\n", decl);
+  return 0;
 }
 
 /* -----------------------------------------------------------------------------
@@ -249,3 +257,61 @@ Wrapper_new_localv(Wrapper *w, const DOHString_or_char *name, ...) {
   return ret;
 }
 
+/* -----------------------------------------------------------------------------
+ * Wrapper_Gettype()
+ * ----------------------------------------------------------------------------- */
+
+DataType *
+Wrapper_Gettype(Wrapper *w) {
+  return w->_type;
+}
+
+/* -----------------------------------------------------------------------------
+ * Wrapper_Settype()
+ * ----------------------------------------------------------------------------- */
+
+void
+Wrapper_Settype(Wrapper *w, DataType *t) {
+  if (w->_type) DelDataType(w->_type);
+  w->_type = CopyDataType(t);
+}
+
+/* -----------------------------------------------------------------------------
+ * Wrapper_Getparms()
+ * ----------------------------------------------------------------------------- */
+
+ParmList *
+Wrapper_Getparms(Wrapper *w) {
+  return w->_parms;
+}
+
+/* -----------------------------------------------------------------------------
+ * Wrapper_Setparms()
+ * ----------------------------------------------------------------------------- */
+
+void
+Wrapper_Setparms(Wrapper *w, ParmList *l) {
+  if (w->_parms) DelParmList(w->_parms);
+  w->_parms = CopyParmList(l);
+}
+
+/* -----------------------------------------------------------------------------
+ * Wrapper_Getname()
+ * ----------------------------------------------------------------------------- */
+
+char *
+Wrapper_Getname(Wrapper *w) {
+  return Char(w->_name);
+}
+
+/* -----------------------------------------------------------------------------
+ * Wrapper_Setname()
+ * ----------------------------------------------------------------------------- */
+
+void
+Wrapper_Setname(Wrapper *w, DOHString_or_char *n) {
+  if (w->_name) Delete(w->_name);
+  w->_name = NewString(n);
+}
+
+