Started conversion of Language API

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@925 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Source/Modules1.1/guile.cxx

@@ -461,15 +461,15 @@ throw_unhandled_guile_type_error (SwigType *d)
 }
 
 // ----------------------------------------------------------------------
-// GUILE::create_function(char *name, char *iname, SwigType *d,
+// GUILE::create_function()
-//                             ParmList *l)
-//
 // Create a function declaration and register it with the interpreter.
 // ----------------------------------------------------------------------
 
 void
-GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
+GUILE::function (DOH *node) {
-{
+  char *name, *iname;
+  SwigType *d;
+  ParmList *l;
   Parm *p;
   DOHString *proc_name = 0;
   char source[256], target[256];
@@ -484,6 +484,11 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
   int numargs = 0;
   int numopt = 0;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  d = Getattr(node,"type");
+  l = Getattr(node,"parms");
+
   // Make a wrapper name for this
   char * wname = new char [strlen (prefix) + strlen (iname) + 2];
   sprintf (wname, "%s%s", prefix, iname);
@@ -722,7 +727,7 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
 }
 
 // -----------------------------------------------------------------------
-// GUILE::link_variable(char *name, char *iname, SwigType *d)
+// GUILE::variable()
 //
 // Create a link to a C variable.
 // This creates a single function PREFIX_var_VARNAME().
@@ -733,13 +738,21 @@ GUILE::create_function (char *name, char *iname, SwigType *d, ParmList *l)
 // -----------------------------------------------------------------------
 
 void
-GUILE::link_variable (char *name, char *iname, SwigType *t)
+GUILE::variable (DOH *node)
 {
+  char *name, *iname;
+  SwigType *t;
+
   DOHString *proc_name;
   char  var_name[256];
   char  *tm;
   Wrapper *f;
 
+
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+
   f = NewWrapper();
   // evaluation function names
 
@@ -879,15 +892,18 @@ GUILE::link_variable (char *name, char *iname, SwigType *t)
 }
 
 // -----------------------------------------------------------------------
-// GUILE::declare_const(char *name, char *iname, SwigType *type, char *value)
+// GUILE::constant()
 //
 // Makes a constant.   Not sure how this is really supposed to work.
 // I'm going to fake out SWIG and create a variable instead.
 // ------------------------------------------------------------------------
 
 void
-GUILE::declare_const (char *name, char *, SwigType *type, char *value)
+GUILE::constant(DOH *node)
 {
+  char   *name;
+  SwigType *type;
+  char   *value;
   int OldStatus = Status;      // Save old status flags
   DOHString *proc_name;
   char   var_name[256];
@@ -895,6 +911,10 @@ GUILE::declare_const (char *name, char *, SwigType *type, char *value)
   char   *tm;
   Wrapper *f;
 
+  name = GetChar(node,"name");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
+
   f = NewWrapper();
   Status = STAT_READONLY;      // Enable readonly mode.
 
@@ -937,7 +957,10 @@ GUILE::declare_const (char *name, char *, SwigType *type, char *value)
     }
     // Now create a variable declaration
 
-    link_variable (var_name, name, type);
+    Hash *nnode = Copy(node);
+    Setattr(nnode,"name",var_name);
+    variable(nnode);
+    Delete(nnode);
     Status = OldStatus;
   }
   Delete(proc_name);

Source/Modules1.1/guile.h

@@ -44,9 +44,9 @@ public :
   GUILE ();
   void parse_args (int, char *argv[]);
   void parse ();
-  void create_function (char *, char *, SwigType *, ParmList *);
+  void function (DOH *node);
-  void link_variable (char *, char *, SwigType *);
+  void variable (DOH *node);
-  void declare_const (char *, char *, SwigType *, char *);
+  void constant (DOH *node);
   void initialize ();
   void headers (void);
   void close (void);

Source/Modules1.1/mzscheme.cxx

@@ -240,8 +240,7 @@ MZSCHEME::get_pointer (String *name, int parm, SwigType *t, Wrapper *f)
 	 "\", \"", SwigType_manglestr(t), "\", ", p, ", argc, argv);\n",0);    
 }
 // ----------------------------------------------------------------------
-// MZSCHEME::create_function(char *name, char *iname, SwigType *d,
+// MZSCHEME::create_function()
-//                             ParmList *l)
 //
 // Create a function declaration and register it with the interpreter.
 // ----------------------------------------------------------------------
@@ -267,8 +266,11 @@ throw_unhandled_mzscheme_type_error (SwigType *d)
 }
 
 void
-MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
+MZSCHEME::function(DOH *node)
 {
+  char *name, *iname;
+  SwigType *d;
+  ParmList *l;
   Parm *p;
   Wrapper *f = NewWrapper();
   String *proc_name = NewString("");
@@ -287,6 +289,11 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
   int argout_set = 0;
   int i = 0;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  d = Getattr(node,"type");
+  l = Getattr(node,"parms");
+
   // Make a wrapper name for this
   char *wname = Char(Swig_name_wrapper(iname));
 
@@ -476,7 +483,7 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
 }
 
 // -----------------------------------------------------------------------
-// MZSCHEME::link_variable(char *name, char *iname, SwigType *d)
+// MZSCHEME::variable()
 //
 // Create a link to a C variable.
 // This creates a single function _wrap_swig_var_varname().
@@ -487,8 +494,10 @@ MZSCHEME::create_function (char *name, char *iname, SwigType *d, ParmList *l)
 // -----------------------------------------------------------------------
 
 void
-MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
+MZSCHEME::variable (DOH *node)
 {
+  char *name, *iname;
+  SwigType *t;
   String *proc_name = NewString("");
   char  var_name[256];
   char  *tm;
@@ -496,6 +505,10 @@ MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
   String *argnum = NewString("0");
   String *arg = NewString("argv[0]");
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+
   // evaluation function names
 
   sprintf (var_name, "_wrap_%svar_%s", prefix, iname);
@@ -604,15 +617,19 @@ MZSCHEME::link_variable (char *name, char *iname, SwigType *t)
 }
 
 // -----------------------------------------------------------------------
-// MZSCHEME::declare_const(char *name, char *iname, SwigType *type, char *value)
+// MZSCHEME::constant()
 //
 // Makes a constant.   Not sure how this is really supposed to work.
 // I'm going to fake out SWIG and create a variable instead.
 // ------------------------------------------------------------------------
 
 void
-MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
+MZSCHEME::constant(DOH *node)
 {
+  char   *name;
+  SwigType *type;
+  char   *value;
+
   int OldStatus = Status;      // Save old status flags
   char   var_name[256];
   String *proc_name = NewString("");
@@ -620,6 +637,10 @@ MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
   String *temp = NewString("");
   char   *tm;
 
+  name = GetChar(node,"name");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
+
   Status = STAT_READONLY;      // Enable readonly mode.
 
   // Make a static variable;
@@ -666,7 +687,10 @@ MZSCHEME::declare_const (char *name, char *, SwigType *type, char *value)
 
     // Now create a variable declaration
 
-    link_variable (var_name, name, type);
+    Hash *nnode = Copy(node);
+    Setattr(nnode,"name",var_name);
+    variable (nnode);
+    Delete(nnode);
     Status = OldStatus;
   }
   Delete(proc_name);

Source/Modules1.1/mzscheme.h

@@ -35,9 +35,9 @@ private:
 public :
   void parse_args (int, char *argv[]);
   void parse ();
-  void create_function (char *, char *, SwigType *, ParmList *);
+  void function (DOH *node);
-  void link_variable (char *, char *, SwigType *);
+  void variable (DOH *node);
-  void declare_const (char *, char *, SwigType *, char *);
+  void constant (DOH *node);
   void initialize ();
   void headers (void);
   void close (void);

Source/Modules1.1/perl5.cxx

@@ -498,8 +498,11 @@ PERL5::create_command(char *cname, char *iname) {
  * PERL5::create_function()
  * ----------------------------------------------------------------------------- */
 void
-PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
+PERL5::function(DOH *node)
 {
+  char *name, *iname;
+  SwigType *d;
+  ParmList *l;
   Parm *p;
   int   pcount,i,j;
   Wrapper *f;
@@ -509,6 +512,11 @@ PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
   int    numopt = 0;
   int    need_save, num_saved = 0;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  d = Getattr(node,"type");
+  l = Getattr(node,"parms");
+
   f       = NewWrapper();
   cleanup = NewString("");
   outarg  = NewString("");
@@ -843,14 +851,20 @@ PERL5::create_function(char *name, char *iname, SwigType *d, ParmList *l)
  * PERL5::link_variable()
  * ----------------------------------------------------------------------------- */
 
-void PERL5::link_variable(char *name, char *iname, SwigType *t)
+void PERL5::variable(DOH *node) {
-{
+  char *name, *iname;
+  SwigType *t;
+
   char  set_name[256];
   char  val_name[256];
   Wrapper  *getf, *setf;
   char  *tm;
   int   setable = 1;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+
   sprintf(set_name,"_wrap_set_%s",iname);
   sprintf(val_name,"_wrap_val_%s",iname);
 
@@ -1073,7 +1087,7 @@ void PERL5::link_variable(char *name, char *iname, SwigType *t)
 }
 
 /* -----------------------------------------------------------------------------
- * PERL5::declare_const()
+ * PERL5::constant()
  * ----------------------------------------------------------------------------- */
 
 /* Functions used to create constants */
@@ -1131,15 +1145,21 @@ static const char *setrv = "#ifndef PERL_OBJECT\
 \n}\n";
 
 void
-PERL5::declare_const(char *name, char *, SwigType *type, char *value)
+PERL5::constant(DOH *node)
   {
-
+  char   *name;
+  SwigType *type;
+  char   *value;
   char   *tm;
   static  int have_int_func = 0;
   static  int have_double_func = 0;
   static  int have_char_func = 0;
   static  int have_ref_func = 0;
 
+  name = GetChar(node,"name");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
+
   if ((tm = Swig_typemap_lookup((char*)"const",type,name,value,name,0))) {
     Printf(f_init,"%s\n",tm);
   } else {

Source/Modules1.1/perl5.h

@@ -25,9 +25,9 @@ private:
 public :
   virtual void parse_args(int, char *argv[]);
   virtual void parse();
-  virtual void create_function(char *, char *, SwigType *, ParmList *);
+  virtual void function(DOH *node);
-  virtual void link_variable(char *, char *, SwigType *);
+  virtual void variable(DOH *node);
-  virtual void declare_const(char *, char *, SwigType *, char *);
+  virtual void constant(DOH *node);
   virtual void initialize(void);
   virtual void close(void);
   virtual void set_module(char *);

Source/Modules1.1/python.cxx

@@ -322,7 +322,11 @@ PYTHON::create_command(char *cname, char *iname) {
  * PYTHON::create_function()
  * ----------------------------------------------------------------------------- */
 void
-PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
+PYTHON::function(DOH *node) {
+  char    *name;
+  char    *iname;
+  SwigType *d;
+  ParmList *l;
   Parm    *p;
   int     pcount,i,j;
   char    wname[256];
@@ -339,6 +343,10 @@ PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
   char     *tm;
   int      numopt = 0;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  d = Getattr(node,"type");
+  l = Getattr(node,"parms");
   f = NewWrapper();
   parse_args = NewString("");
   arglist = NewString("");
@@ -670,15 +678,21 @@ PYTHON::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
 }
 
 /* -----------------------------------------------------------------------------
- * PYTHON::link_variable()
+ * PYTHON::variable()
  * ----------------------------------------------------------------------------- */
 void
-PYTHON::link_variable(char *name, char *iname, SwigType *t) {
+PYTHON::variable(DOH *node) {
+    char *name, *iname;
+    SwigType *t;
     char   *wname;
     static int have_globals = 0;
     char   *tm;
     Wrapper *getf, *setf;
 
+    name = GetChar(node,"name");
+    iname = GetChar(node,"scriptname");
+    t = Getattr(node,"type");
+
     getf = NewWrapper();
     setf = NewWrapper();
 
@@ -908,12 +922,19 @@ PYTHON::link_variable(char *name, char *iname, SwigType *t) {
 }
 
 /* -----------------------------------------------------------------------------
- * PYTHON::declare_const()
+ * PYTHON::constant()
  * ----------------------------------------------------------------------------- */
 void
-PYTHON::declare_const(char *name, char *, SwigType *type, char *value) {
+PYTHON::constant(DOH *node) {
+  char   *name;
+  SwigType *type;
+  char   *value;
   char   *tm;
 
+  name = GetChar(node,"name");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
+  
   if ((tm = Swig_typemap_lookup((char*)"const",type,name,value,name,0))) {
     Printf(const_code,"%s\n", tm);
   } else {

Source/Modules1.1/python.h

@@ -33,9 +33,9 @@ public :
   // Don't change any of this
   virtual void parse_args(int, char *argv[]);
   virtual void parse();
-  virtual void create_function(char *, char *, SwigType *, ParmList *);
+  virtual void function(DOH *node);
-  virtual void link_variable(char *, char *, SwigType *);
+  virtual void variable(DOH *node);
-  virtual void declare_const(char *, char *, SwigType *, char *);
+  virtual void constant(DOH *node);
   virtual void initialize(void);
   virtual void close(void);
   virtual void set_module(char *);

Source/Modules1.1/ruby.cxx

@@ -427,22 +427,27 @@ void RUBY::create_command(char *cname, char *iname, int argc) {
 }
 
 /* ---------------------------------------------------------------------
- * RUBY::create_function(char *name, char *iname, SwigType *d, ParmList *l)
+ * RUBY::function()
  *
  * Create a function declaration and register it with the interpreter.
- *              name = Name of real C function
- *              iname = Name of function in scripting language
- *              t = Return datatype
- *              l = Function parameters
  * --------------------------------------------------------------------- */
 
-void RUBY::create_function(char *name, char *iname, SwigType *t, ParmList *l) {
+void RUBY::function(DOH *node) {
+  char *name, *iname;
+  SwigType *t;
+  ParmList *l;
+
   char source[256], target[256];
   char *tm;
   String *cleanup, *outarg;
   Wrapper *f;
   int i;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+  l = Getattr(node,"parms");
+
   /* Ruby needs no destructor wrapper */
   if (current == DESTRUCTOR) {
     Wrapper *dummy = NewWrapper();
@@ -687,20 +692,24 @@ void RUBY::create_function(char *name, char *iname, SwigType *t, ParmList *l) {
 }
 
 /* ---------------------------------------------------------------------
- * RUBY::link_variable(char *name, char *iname, SwigType *t)
+ * RUBY::variable()
  *
  * Create a link to a C variable.
- *              name = Name of C variable
- *              iname = Name of variable in scripting language
- *              t = Datatype of the variable
  * --------------------------------------------------------------------- */
 
-void RUBY::link_variable(char *name, char *iname, SwigType *t) {
+void RUBY::variable(DOH *node) {
+  char *name, *iname;
+  SwigType *t;
+
   char *tm, *source;
 
   String *getfname, *setfname;
   Wrapper *getf, *setf;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+
   getf = NewWrapper();
   setf = NewWrapper();
 
@@ -848,17 +857,21 @@ char *RUBY::validate_const_name(char *name) {
 }
 
 /* ---------------------------------------------------------------------
- * RUBY::declare_const(char *name, char *iname, SwigType *type, char *value)
+ * RUBY::constant()
  *
  * Makes a constant.
- *              name = Name of the constant
- *              iname = Scripting language name of constant
- *              type = Datatype of the constant
- *              value = Constant value (as a string)
  * --------------------------------------------------------------------- */
 
-void RUBY::declare_const(char *name, char *iname, SwigType *type, char *value) {
+void RUBY::constant(DOH *node) {
   char *tm;
+  char   *name, *iname;
+  SwigType *type;
+  char   *value;
+
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
 
   if (current == CLASS_CONST)
     iname = klass->strip(iname);

Source/Modules1.1/ruby.h

@@ -21,9 +21,9 @@ class RUBY : public Language {
   /* Virtual functions required by the SWIG parser */
   virtual void parse_args(int, char *argv[]);
   virtual void parse();
-  virtual void create_function(char *, char *, SwigType *, ParmList *);
+  virtual void function(DOH *node);
-  virtual void link_variable(char *, char *, SwigType *);
+  virtual void variable(DOH *node);
-  virtual void declare_const(char *, char *, SwigType *, char *);
+  virtual void constant(DOH *node);
   virtual void initialize(void);
   virtual void close(void);
   virtual void set_module(char *);

Source/Modules1.1/tcl8.cxx

@@ -264,7 +264,10 @@ TCL8::create_command(char *cname, char *iname) {
  * ----------------------------------------------------------------------------- */
 
 void
-TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
+TCL8::function(DOH *node) {
+  char *name, *iname;
+  SwigType *d;
+  ParmList *l;
   Parm            *p;
   int              pcount,i,j;
   char            *tm;
@@ -272,6 +275,11 @@ TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
   String          *incode, *cleanup, *outarg, *argstr, *args;
   int              numopt= 0;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  d = Getattr(node,"type");
+  l = Getattr(node,"parms");
+
   incode  = NewString("");
   cleanup = NewString("");
   outarg  = NewString("");
@@ -530,14 +538,16 @@ TCL8::create_function(char *name, char *iname, SwigType *d, ParmList *l) {
 }
 
 /* -----------------------------------------------------------------------------
- * TCL8::link_variable()
+ * TCL8::variable()
  * ----------------------------------------------------------------------------- */
 
 static Hash      *setf = 0;
 static Hash      *getf = 0;
 
 void
-TCL8::link_variable(char *name, char *iname, SwigType *t) {
+TCL8::variable(DOH *node) {
+  char *name, *iname;
+  SwigType *t;
 
   String *setname;
   String *getname;
@@ -547,6 +557,10 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
   int setable = 1;
   int tc;
 
+  name = GetChar(node,"name");
+  iname = GetChar(node,"scriptname");
+  t = Getattr(node,"type");
+
   if (!setf) setf = NewHash();
   if (!getf) getf = NewHash();
 
@@ -755,17 +769,26 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
 }
 
 /* -----------------------------------------------------------------------------
- * TCL8::declare_const()
+ * TCL8::constant()
  * ----------------------------------------------------------------------------- */
 
 void
-TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
+TCL8::constant(DOH *node) {
+  char   *name;
+  SwigType *type;
+  char   *value;
   int OldStatus = Status;
   SwigType *t;
   char      var_name[256];
   char     *tm;
   String   *rvalue;
   Status = STAT_READONLY;
+  DOH      *nnode;
+
+  name = GetChar(node,"name");
+  type = Getattr(node,"type");
+  value = GetChar(node,"value");
+  nnode = Copy(node);
 
   /* Make a static variable */
   sprintf(var_name,"_wrap_const_%s",name);
@@ -784,7 +807,8 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
     switch(SwigType_type(type)) {
     case T_BOOL: case T_INT: case T_DOUBLE:
       Printf(f_header,"static %s %s = %s;\n", SwigType_str(type,0), var_name, value);
-      link_variable(var_name,name,type);
+      Setattr(nnode,"name",var_name);
+      variable(nnode);
       break;
 
     case T_SHORT:
@@ -801,7 +825,9 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
       sprintf(var_name,"%s_char",var_name);
       t = NewString("char");
       SwigType_add_pointer(t);
-      link_variable(var_name,name,t);
+      Setattr(nnode,"name",var_name);
+      Setattr(nnode,"type",t);
+      variable(nnode);
       Delete(t);
       break;
 
@@ -820,25 +846,31 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
       sprintf(var_name,"%s_char",var_name);
       t = NewSwigType(T_CHAR);
       SwigType_add_pointer(t);
-      link_variable(var_name,name,t);
+      Setattr(nnode,"name",var_name);
+      Setattr(nnode,"type",t);
+      variable(nnode);
       Delete(t);
       break;
 
     case T_FLOAT:
       Printf(f_header,"static %s %s = (%s) (%s);\n", SwigType_lstr(type,0), var_name, SwigType_lstr(type,0), value);
-      link_variable(var_name,name,type);
+      Setattr(nnode,"name",var_name);
+      variable(nnode);
       break;
 
     case T_CHAR:
       SwigType_add_pointer(type);
       Printf(f_header,"static %s %s = \"%s\";\n", SwigType_lstr(type,0), var_name, value);
-      link_variable(var_name,name,type);
+      Setattr(nnode,"name",var_name);
+      Setattr(nnode,"type",type);
+      variable(nnode);
       SwigType_del_pointer(type);
       break;
 
     case T_STRING:
       Printf(f_header,"static %s %s = \"%s\";\n", SwigType_lstr(type,0), var_name, value);
-      link_variable(var_name,name,type);
+      Setattr(nnode,"name",var_name);
+      variable(nnode);
       break;
 
     case T_POINTER: case T_ARRAY: case T_REFERENCE:
@@ -855,7 +887,9 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
       Printf(f_init,"\t SWIG_MakePtr(%s_char, (void *) %s, SWIGTYPE%s);\n",
 	     var_name, var_name, SwigType_manglestr(type));
       sprintf(var_name,"%s_char",var_name);
-      link_variable(var_name,name,t);
+      Setattr(nnode,"type",t);
+      Setattr(nnode,"name",var_name);
+      variable(nnode);
       Delete(t);
       break;
 
@@ -865,6 +899,7 @@ TCL8::declare_const(char *name, char *, SwigType *type, char *value) {
     }
   }
   Delete(rvalue);
+  Delete(nnode);
   Status = OldStatus;
 }
 

Source/Modules1.1/tcl8.h

@@ -27,9 +27,9 @@ private:
 public :
   virtual void parse_args(int, char *argv[]);
   virtual void parse();
-  virtual void create_function(char *, char *, SwigType *, ParmList *);
+  virtual void function(DOH *node);
-  virtual void link_variable(char *, char *, SwigType *);
+  virtual void variable(DOH *node);
-  virtual void declare_const(char *, char *, SwigType *, char *);
+  virtual void constant(DOH *node);
   virtual void initialize(void);
   virtual void close(void);
   virtual void set_module(char *);

Source/SWIG1.1/cplus.cxx

@@ -1561,7 +1561,7 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
       /* Nah. Just produce a string that does the work for us */
       emit_set_action(Swig_cmethod_call(mname, Wrapper_Getparms(w)));
     }
-    lang->create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
+    new_create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
     DelWrapper(w);
   } else {
     lang->create_command(prev_wrap, iname);
@@ -1660,15 +1660,15 @@ void cplus_emit_static_func(char *classname, char *, char *classrename,
     if (!prev_wrap) {
       if (!mode) {
 	// Not an added method and not objective C, just wrap it
-	lang->create_function(cname,iname, type, l);
+	new_create_function(cname,iname, type, l);
       } else {
 	if (!ccode) {
 	  strcpy(cname, Char(Swig_name_member(classname,mname)));
-	  lang->create_function(cname,iname, type, l);
+	  new_create_function(cname,iname, type, l);
 	} else {
 	  Wrapper *w = Swig_cfunction_wrapper(cname, type, l, ccode);
 	  Wrapper_print(w,f_wrappers);	  
-	  lang->create_function(cname,iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
+	  new_create_function(cname,iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
 	  DelWrapper(w);
 	}
       }
@@ -1735,15 +1735,15 @@ void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
     }
     if (mode && ccode) {
       Wrapper_print(w,f_wrappers);
-      lang->create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
+      new_create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
     } else if (mode) {
-      lang->create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
+      new_create_function(Wrapper_Getname(w),iname,Wrapper_Gettype(w), Wrapper_Getparms(w));
     } else {
       if (CPlusPlus) 
 	emit_set_action(Swig_cppdestructor_call());
       else
 	emit_set_action(Swig_cdestructor_call());
-      lang->create_function(cname, iname, Wrapper_Gettype(w), Wrapper_Getparms(w));      
+      new_create_function(cname, iname, Wrapper_Gettype(w), Wrapper_Getparms(w));      
     }
     DelWrapper(w);
 }
@@ -1803,7 +1803,7 @@ void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
 	Wrapper_print(w,f_wrappers);
       }
     }
-    lang->create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
+    new_create_function(Wrapper_Getname(w), iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
     DelWrapper(w);
 }
 
@@ -1893,7 +1893,7 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename
       } else if (!mode) {
 	emit_set_action(Swig_cmemberget_call(mname, type));
       }
-      lang->create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
+      new_create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
     } else {
       // Already wrapped this function.  Just patch it up
       lang->create_command(prev_wrap,iname);
@@ -2002,7 +2002,7 @@ void cplus_emit_variable_set(char *classname, char *classtype, char *classrename
 	  emit_set_action(tm);
 	Delete(target);
       }
-      lang->create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
+      new_create_function(Wrapper_Getname(w),iname, Wrapper_Gettype(w), Wrapper_Getparms(w));
     } else {
       lang->create_command(prev_wrap,iname);
     } 

Source/SWIG1.1/emit.cxx

@@ -19,6 +19,23 @@ extern "C" {
 
 static char cvsroot[] = "$Header$";
 
+/* -----------------------------------------------------------------------------
+ * new_create_function()
+ * 
+ * Create a new function
+ * ----------------------------------------------------------------------------- */
+
+void new_create_function(char *name, char *iname, SwigType *type, ParmList *l) {
+  Hash *h;
+  h = NewHash();
+  Setattr(h,"name",name);
+  Setattr(h,"scriptname",iname);
+  Setattr(h,"type",type);
+  Setattr(h,"parms",l);
+  lang->function(h);
+  Delete(h);
+}
+
 /* -----------------------------------------------------------------------------
  * emit_args()
  *
@@ -169,7 +186,7 @@ void emit_set_get(char *name, char *iname, SwigType *t) {
     Wrapper_print(w,f_header);
     new_iname = Swig_name_set(iname);
     DohIncref(new_iname);
-    lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
+    new_create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
     Delete(new_iname);
     DelWrapper(w);
   }
@@ -178,7 +195,7 @@ void emit_set_get(char *name, char *iname, SwigType *t) {
   Wrapper_print(w,f_header);
   new_iname = Swig_name_get(iname);
   DohIncref(new_iname);
-  lang->create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
+  new_create_function(Wrapper_Getname(w), Char(new_iname), Wrapper_Gettype(w), Wrapper_Getparms(w));
   Delete(new_iname);
   DelWrapper(w);
 }

Source/SWIG1.1/internal.h

@@ -39,4 +39,26 @@ struct TMParm {
 
 #define NI_NAMES    512
 
+// Some functions for emitting some C++ helper code
+extern void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
+                                   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, SwigType *type, ParmList *l,
+                                   int mode);
+
+extern void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
+                                  char *name, char *iname, int mode);
+
+extern void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
+                                   char *name, char *iname, ParmList *l, int mode);
+
+extern void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
+				    char *name, char *iname, SwigType *type, int mode);
+
+extern void cplus_emit_variable_set(char *classname, char *classtype, char *classrename,
+				    char *name, char *iname, SwigType *type, int mode);
+
+extern char *cplus_base_class(char *name);
 

Source/SWIG1.1/lang.cxx

@@ -337,8 +337,14 @@ void Language::cpp_declare_const(char *name, char *iname, SwigType *type, char *
   } else {
     new_value = value;
   }
-
+  Hash *n;
-  lang->declare_const(cname,cname,type, new_value);
+  n = NewHash();
+  Setattr(n,"name",cname);
+  Setattr(n,"scriptname",cname);
+  Setattr(n,"type",type);
+  Setattr(n,"value",new_value);
+  lang->constant(n);
+  Delete(n);
   
   if (!value) {
     free(new_value);
@@ -384,7 +390,12 @@ void Language::cpp_static_var(char *name, char *iname, SwigType *t) {
 
   /* Link with this variable */
 
-  lang->link_variable(mname,cname,t);
+  Hash *n = NewHash();
+  Setattr(n,"name",mname);
+  Setattr(n,"scriptname", cname);
+  Setattr(n,"type",t);
+  lang->variable(n);
+  Delete(n);
 }
 
 /* -----------------------------------------------------------------------------

Source/SWIG1.1/parser.yxx

@@ -274,6 +274,7 @@ static char *make_name(char *name) {
 // ----------------------------------------------------------------------
 
 void create_function(int ext, char *name, SwigType *t, ParmList *l) {
+  DOH *n;
   if (Active_static) return;     // Static declaration. Ignore
 
   init_language();
@@ -296,8 +297,13 @@ void create_function(int ext, char *name, SwigType *t, ParmList *l) {
       emit_extern_func(name, t, l, 1, f_header);
     }
 
-    // If this function has been declared inline, produce a function
+    n = NewHash();
-    lang->create_function(name, iname, t, l);
+    Setattr(n,"name", name);
+    Setattr(n,"scriptname", iname);
+    Setattr(n,"type", t);
+    Setattr(n,"parms", l);
+    lang->function(n);
+    Delete(n);
   }
   scanner_clear_start();
 }
@@ -328,7 +334,13 @@ void create_variable(int ext, char *name, SwigType *t) {
     }
 
     // Now dump it out
-    lang->link_variable(name, iname, t);
+    Hash *n;
+    n = NewHash();
+    Setattr(n,"name",name);
+    Setattr(n,"scriptname", iname);
+    Setattr(n,"type",t);
+    lang->variable(n);
+    Delete(n);
   }
   scanner_clear_start();
 }
@@ -362,7 +374,14 @@ void create_constant(char *name, SwigType *type, char *value) {
   } else {
     if (!WrapExtern) {    // Only wrap the constant if not in %extern mode
       String *tval = NewStringf("%(escape)s",value);
-      lang->declare_const(name, name, type, Char(tval));
+      Hash *n;
+      n = NewHash();
+      Setattr(n,"name",name);
+      Setattr(n,"scriptname",name);
+      Setattr(n,"type",type);
+      Setattr(n,"value",tval);
+      lang->constant(n);
+      Delete(n);
       Delete(tval);
     }
   }

Source/SWIG1.1/swig11.h

@@ -87,93 +87,15 @@ struct Pragma {
   Pragma  *next;
 };
 
-/************************************************************************
+/* Real Language Class */
- * class language:
- *
- * This class defines the functions that need to be supported by the
- * scripting language being used.    The translator calls these virtual
- * functions to output different types of code for different languages.
- *
- * By implementing this using virtual functions, hopefully it will be
- * easy to support different types of scripting languages.
- *
- * The following functions are used :
- *
- *    parse_args(argc, argv)
- *           Parse the arguments used by this language.
- *
- *    parse()
- *           Entry function that starts parsing of a particular language
- *
- *    create_function(fname, iname, rtype, parmlist)
- *           Creates a function wrappper.
- *
- *    link_variable(vname, iname, type)
- *           Creates a link to a variable.
- *
- *    declare_const(cname, type, value)
- *           Creates a constant (for #define).
- *
- *    initialize(char *fn)
- *           Produces initialization code.
- *
- *    headers()
- *           Produce code for headers
- *
- *    close()
- *           Close up files
- *
- *    usage_var(iname,type,string)
- *           Produces usage string for variable declaration.
- *
- *    usage_func(iname,rttype, parmlist, string)
- *           Produces usage string for function declaration.
- *
- *    usage_const(iname, type, value, string)
- *           Produces usage string for constants
- *
- *    set_module(char *modname)
- *           Sets the name of the module (%module directive)
- *
- *    add_native(char *name, char *funcname);
- *           Adds a native wrapper function to the initialize process
- *
- * --- C++ Functions ---
- *
- *    These functions are optional additions to any of the target
- *    languages.   SWIG handles inheritance, symbol tables, and other
- *    information.
- *
- *    cpp_open_class(char *classname, char *rname)
- *          Open a new C++ class definition.
- *    cpp_close_class(char *)
- *          Close current C++ class
- *    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, 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, SwigType *t, ParmList *l)
- *          A C++ static member function.
- *    cpp_static_var(char *name, char *iname, SwigType *t)
- *          A C++ static member data variable.
- *
- *************************************************************************/
-
 class Language {
 public:
   virtual void parse_args(int argc, char *argv[]) = 0;
   virtual void parse() = 0;
-  virtual void create_function(char *, char *, SwigType *, ParmList *) = 0;
+  virtual void function(DOH *node) = 0;
-  virtual void link_variable(char *, char *, SwigType *)  = 0;
+  virtual void variable(DOH *node) = 0;
-  virtual void declare_const(char *, char *, SwigType *, char *) = 0;
+  virtual void constant(DOH *node) = 0;
+
   virtual void initialize(void) = 0;
   virtual void close(void) = 0;
   virtual void set_module(char *mod_name) = 0;
@@ -215,36 +137,13 @@ public:
 
 /* Emit functions */
 
+extern  void  new_create_function(char *, char *, SwigType *, ParmList *);
 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 *);
 
-// Some functions for emitting some C++ helper code
-
-extern void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
-                                   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, SwigType *type, ParmList *l,
-                                   int mode);
-
-extern void cplus_emit_destructor(char *classname, char *classtype, char *classrename,
-                                  char *name, char *iname, int mode);
-
-extern void cplus_emit_constructor(char *classname, char *classtype, char *classrename,
-                                   char *name, char *iname, ParmList *l, int mode);
-
-extern void cplus_emit_variable_get(char *classname, char *classtype, char *classrename,
-				    char *name, char *iname, SwigType *type, int mode);
-
-extern void cplus_emit_variable_set(char *classname, char *classtype, char *classrename,
-				    char *name, char *iname, SwigType *type, int mode);
-
-extern char *cplus_base_class(char *name);
-
 /* These are in the new core */
 
 extern "C" {

Source/Swig/swig.h

@@ -415,6 +415,7 @@ extern void   Swig_except_clear();
 #define Getvalue(x)        Getattr(x,"value")
 #define Getlname(x)        Getattr(x,"lname")
 #define Getignore(x)       GetInt(x,"ignore")
+#define Getparms(x)        Getattr(x,"parms")
 
 #define Settype(x,v)       Setattr(x,"type",x)
 #define Setname(x,v)       Setattr(x,"name",v)