Lot's of cleanup. Removed some more source files. Migrated more functionality to C.

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

SWIG/CHANGES

@@ -1,5 +1,17 @@
 SWIG (Simplified Wrapper and Interface Generator)
 
+Version 1.3 Alpha 3 (June 18, 2000)
+===================================
+
+6/18/00 : beazley
+          Removed the naming.cxx, hash.cxx, and symbol.cxx files from
+          the SWIG1.1 directory.   Continued to migrate things away
+          from the C++ base (although there's still a lot of work to do).
+
+6/17/00 : beazley
+          Added a few more examples to the Examples directory.  Still
+          need to do a lot of work on this.
+
 6/16/00 : beazley
           Added -includeall to follow all #include statements in the
           preprocessor.

SWIG/README

@@ -22,15 +22,18 @@ SWIG release.  The guilty parties working on this are:
 *****             IMPORTANT NOTICE -- READ THIS NOW!              *****
 ***********************************************************************
 
-If you downloaded SWIG as a prepackaged release such as SWIG1.3a2, be
+If you downloaded SWIG as a prepackaged release such as SWIG1.3a3, be
 advised that this distribution represents a snapshot of the most
 stable part of the SWIG CVS repository.  As this is an unstable
 release, there is a pretty good chance that a number of features are
 broken or under repair.  Currently, SWIG is undergoing a large
-redevelopment effort.  The SWIG1.3 series of releases should be viewed
+redevelopment effort in which it is being converted from C++ to ANSI
-as a transitional releases leading to the eventual release of SWIG2.0.
+C.  As a result, the source code is a little disorganized at the
-First-time users may want to start with SWIG1.1p5 which is significantly
+moment.  The SWIG1.3 series of releases should be viewed as
-more stable (and includes a wider range of documentation and examples).
+transitional releases leading to the eventual release of
+SWIG2.0. First-time users may want to start with SWIG1.1p5 which is
+significantly more stable (and includes a wider range of documentation
+and examples).
 
 Please report any errors and submit patches (if possible)!  We only
 have access to a limited variety of hardware (Linux, Solaris, and
@@ -70,6 +73,11 @@ What's Broken?
 
    - SWIG requires an ANSI C compiler.
 
+   - A number of low-level data structures have been converted
+     to C.  Since things haven't yet been fully tested, there's 
+     a chance that unusual corner cases might cause SWIG to crash.
+     If so, please send us a debugger traceback if possible.
+
 Installation
 ============
 To build and install SWIG, simply type the following:

SWIG/Source/Modules1.1/guile.cxx

@@ -233,7 +233,7 @@ GUILE::set_init (char *iname)
 void
 GUILE::headers (void)
 {
-  emit_banner (f_header);
+  Swig_banner (f_header);
 
   fprintf (f_header, "/* Implementation : GUILE */\n\n");
 

SWIG/Source/Modules1.1/java.cxx

@@ -399,7 +399,7 @@ void JAVA::set_module(char *mod_name, char **mod_list) {
 
 void JAVA::headers(void)
 {
-  emit_banner(f_header);               // Print the SWIG banner message
+  Swig_banner(f_header);               // Print the SWIG banner message
   fprintf(f_header,"/* Implementation : Java */\n\n");
 
   // Include header file code fragment into the output

SWIG/Source/Modules1.1/mzscheme.cxx

@@ -179,7 +179,7 @@ MZSCHEME::set_init (char *iname)
 void
 MZSCHEME::headers (void)
 {
-  emit_banner (f_header);
+  Swig_banner (f_header);
 
   fprintf (f_header, "/* Implementation : MZSCHEME */\n\n");
   fprintf (f_header, "#include <stdio.h>\n");

SWIG/Source/Modules1.1/perl5.cxx

@@ -290,7 +290,7 @@ void PERL5::set_init(char *iname) {
 void PERL5::headers(void)
 {
 
-  emit_banner(f_header);
+  Swig_banner(f_header);
 
   if (!alt_header) {
     if (Swig_insert_file("headers.swg", f_header) == -1) {

SWIG/Source/Modules1.1/python.cxx

@@ -258,7 +258,7 @@ void PYTHON::print_methods() {
 void PYTHON::headers(void)
 {
 
-  emit_banner(f_runtime);
+  Swig_banner(f_runtime);
 
   fprintf(f_runtime,"/* Implementation : PYTHON */\n\n");
   fprintf(f_runtime,"#define SWIGPYTHON\n");

SWIG/Source/Modules1.1/tcl8.cxx

@@ -233,7 +233,7 @@ void TCL8::set_init(char *iname) {
 void TCL8::headers(void)
 {
 
-  emit_banner(f_runtime);
+  Swig_banner(f_runtime);
   
   // Include a Tcl configuration file for Unix,Mac,Wintel.
 

SWIG/Source/SWIG1.1/Makefile.in

@@ -14,12 +14,12 @@ RANLIB   = @RANLIB@
 
 TARGET   = libswig11.a
 
-OBJS     = parser.o main.o scanner.o symbol.o types.o parms.o \
+OBJS     = parser.o main.o scanner.o types.o parms.o \
-           emit.o cplus.o lang.o hash.o sstring.o wrapfunc.o \
+           emit.o cplus.o lang.o sstring.o wrapfunc.o \
            typemap.o
 
-SRCS     = main.cxx scanner.cxx symbol.cxx types.cxx parms.cxx \
+SRCS     = main.cxx scanner.cxx types.cxx parms.cxx \
-           emit.cxx cplus.cxx lang.cxx hash.cxx \
+           emit.cxx cplus.cxx lang.cxx \
            sstring.cxx wrapfunc.cxx typemap.cxx
 
 PARSER   = $(srcdir)/parser.yxx

SWIG/Source/SWIG1.1/cplus.cxx

@@ -86,7 +86,7 @@ static char cvstag[] = "$Header$";
 
 static int    Inherit_mode = 0;             // Set if we're inheriting members
 static char   *ccode = 0;                   // Set to optional C code (if available)
-static Hash   *localtypes;                  // Localtype hash
+static DOHHash  *localtypes = 0;                  // Localtype hash
 static int    abstract =0;                  // Status bit set during code generation
 
 static int    cpp_id = 0;
@@ -116,7 +116,7 @@ static void add_local_type(char *type, char *classname) {
   if (!localtypes) return;        // No hash table initialized, ignore this
 
   str << classname << "::" << type;
-  localtypes->add(type,copy_string(str));
+  Setattr(localtypes,type,str.get());
 }
 
 void add_local_type(DataType *type, char *classname) {
@@ -139,7 +139,7 @@ static void update_local_type(DataType *type) {
 
   if (!localtypes) return;
 
-  newname = (char *) localtypes->lookup(type->name);
+  newname = GetChar(localtypes,type->name);
   if (newname) {
     strcpy(type->name, newname);
   }
@@ -162,7 +162,7 @@ static void update_parms(ParmList *l) {
 
     if ((p->defvalue) && (localtypes)) {
       char *s;
-      s = (char *) localtypes->lookup(p->defvalue);
+      s = (char *) GetChar(localtypes,p->defvalue);
       if (s) {
 	delete p->defvalue;
 	p->defvalue = copy_string(s);
@@ -501,7 +501,7 @@ public:
   int          error;                 // Set if this class can't be generated
   int          line;                  // Line number
   char        **baseclass;            // Base classes (if any)
-  Hash        *local;                 // Hash table for local types
+  DOHHash     *local;                 // Hash table for local types
   void        *scope;                 // Local scope hash table
   CPP_member  *members;               // Linked list of members
   CPP_class   *next;                  // Next class
@@ -514,7 +514,7 @@ public:
     classtype = copy_string(ctype);
     classrename = 0;
     baseclass = 0;
-    local = new Hash;                 // Create hash table for storing local datatypes
+    local = NewHash();                 // Create hash table for storing local datatypes
     scope = 0;
     error = 0;
     pragmas = 0;
@@ -944,7 +944,7 @@ void cplus_inherit(int count, char **baseclass) {
 //
 // -----------------------------------------------------------------------------
 
-static Hash convert;                // Hash table of conversion functions
+static DOHHash *convert = 0;                // Hash table of conversion functions
 
 void cplus_generate_types(char **baseclass) {
   CPP_class *bc;
@@ -956,6 +956,8 @@ void cplus_generate_types(char **baseclass) {
     return;
   }
 
+  if (!convert) convert = NewHash();
+
   // Generate type-conversion functions and type-equivalence
 
   i = 0;
@@ -970,7 +972,8 @@ void cplus_generate_types(char **baseclass) {
 	temp3 = "";
 	temp3 << "Swig" << current_class->classname << "To" << bc->classname;
 
-	if (convert.add(temp3,(void *) 1) != -1) {
+	if (!Getattr(convert,temp3.get())) {
+	  SetVoid(convert,temp3.get(),(void*) 1);
 
 	  // Write a function for casting derived type to parent class
 
@@ -1300,9 +1303,6 @@ void cplus_declare_const(char *name, char *iname, DataType *type, char *value) {
   CPP_constant *c =  new CPP_constant(name, temp_iname, type, value);
   current_class->add_member(c);
 
-  // Update this symbol in the symbol table
-  update_symbol(name, type, value);
-
   // Add this symbol to local scope of a class
   add_local_type(name, current_class->classname);
 }
@@ -1387,7 +1387,7 @@ void cplus_add_pragma(char *lang, char *name, char *value)
 // sharing code between base and derived classes.
 // -----------------------------------------------------------------------------
 
-static Hash member_hash;  // Hash wrapping member function wrappers to scripting wrappers
+static DOHHash *member_hash = 0;  // Hash wrapping member function wrappers to scripting wrappers
 
 // -----------------------------------------------------------------------------
 // void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
@@ -1516,9 +1516,13 @@ void cplus_emit_member_func(char *classname, char *classtype, char *classrename,
     l->print_types(key);
     //    printf("key = %s\n", (char *) key);  
     char *temp = copy_string(iname);
-    if ((member_hash.add(key,temp)) == -1) {
+    if (!member_hash) member_hash = NewHash();
+    if (Getattr(member_hash,key.get())) {
+      delete [] temp;
+      prev_wrap = GetChar(member_hash,key.get());
+    } else {
+      Setattr(member_hash,key.get(),temp);
       delete [] temp;
-      prev_wrap = (char *) member_hash.lookup(key);
     }
     
     // Only generate code if an already existing wrapper doesn't exist
@@ -1730,9 +1734,13 @@ void cplus_emit_static_func(char *classname, char *, char *classrename,
     key << cname << "+";
     l->print_types(key);
     char *temp = copy_string(iname);
-    if ((member_hash.add(key,temp)) == -1) {
+    if (!member_hash) member_hash = NewHash();
+    if (Getattr(member_hash,key.get())) {
+      delete [] temp;
+      prev_wrap = GetChar(member_hash,key.get());
+    } else {
+      Setattr(member_hash,key.get(),temp);
       delete [] temp;
-      prev_wrap = (char *) member_hash.lookup(key);
     }
 
     if (!prev_wrap) {
@@ -2151,9 +2159,13 @@ void cplus_emit_variable_get(char *classname, char *classtype, char *classrename
 
     key << cname;
     char *temp = copy_string(iname);
-    if ((member_hash.add(key,temp)) == -1) {
+    if (!member_hash) member_hash = NewHash();
+    if (Getattr(member_hash,key.get())) {
+      delete [] temp;
+      prev_wrap = GetChar(member_hash,key.get());
+    } else {
+      Setattr(member_hash,key.get(),temp);
       delete [] temp;
-      prev_wrap = (char *) member_hash.lookup(key);
     }
 
     // Only generate code if already existing wrapper doesn't exist
@@ -2328,9 +2340,13 @@ void cplus_emit_variable_set(char *classname, char *classtype, char *classrename
 
     key << cname;
     char *temp = copy_string(iname);
-    if ((member_hash.add(key,temp)) == -1) {
+    if (!member_hash) member_hash = NewHash();
+    if (Getattr(member_hash,key.get())) {
+      delete [] temp;
+      prev_wrap = GetChar(member_hash,key.get());
+    } else {
+      Setattr(member_hash,key.get(),temp);
       delete [] temp;
-      prev_wrap = (char *) member_hash.lookup(key);
     }
 
     // Only generate code if already existing wrapper doesn't exist
@@ -2519,9 +2535,9 @@ void cplus_register_scope(void *h) {
 void cplus_inherit_scope(int count, char **baseclass) {
   CPP_class *bc;
   int i;
-  char *key, *val;
+  char *val;
   String str;
-
+  DOH  *key;
   if (count && current_class) {
     for (i = 0; i < count; i++) {
        bc = CPP_class::search(baseclass[i]);
@@ -2531,13 +2547,13 @@ void cplus_inherit_scope(int count, char **baseclass) {
 
 	if (bc->local) {
 	  // Copy local symbol table
-	  key = bc->local->firstkey();
+	  key = Firstkey(bc->local);
 	  while (key) {
-	    val = (char *) bc->local->lookup(key);
+	    val = GetChar(bc->local,key);
 	    str = val;
 	    //	    str.replace(bc->classname,current_class->classname);
-	    localtypes->add(key,copy_string(str));
+	    Setattr(localtypes,key,str.get());
-	    key = bc->local->nextkey();
+	    key = Nextkey(bc->local);
 	  }
 	}
       }

SWIG/Source/SWIG1.1/emit.cxx

@@ -17,43 +17,8 @@ extern "C" {
 #include "swig.h"
 }
 
-
 static char cvsroot[] = "$Header$";
 
-// -----------------------------------------------------------------------------
-// void emit_banner(FILE *f)
-//
-// Emits the SWIG identifying banner in the wrapper file
-// -----------------------------------------------------------------------------
-
-void emit_banner(FILE *f) {
-
-  extern char *get_time();
-  extern char fn_runtime[];
-
-  fprintf(f,
-"/*\n\
- * FILE : %s\n\
- * \n\
- * This file was automatically generated by SWIG (http://www.swig.org).\n\
- * Version %s %s\n\
- * \n\
- * Portions Copyright (c) 1995-1999\n\
- * The University of Utah, The Regents of the University of California, and\n\
- * The University of Chicago.  Permission is granted to use and distribute this\n\
- * file in any manner provided this notice remains intact.\n\
- * \n\
- * This file is not intended to be easily readable and contains a number of \n\
- * coding conventions designed to improve portability and efficiency. Do not make\n\
- * changes to this file unless you know what you are doing--modify the SWIG \n\
- * interface file instead. \n\
- *\n\
- */\n\n", fn_runtime, SWIG_VERSION, SWIG_SPIN);
-
-  fprintf(f,"\n#define SWIGCODE\n");
-
-}
-
 // -----------------------------------------------------------------------------
 // emit_extern_var(char *decl, DataType *t, int extern_type, FILE *f)
 //

SWIG/Source/SWIG1.1/hash.cxx

@@ -1,90 +0,0 @@
-/* ----------------------------------------------------------------------------- 
- * hash.cxx
- *
- *     Hash table object.
- * 
- * Author(s) : David Beazley (beazley@cs.uchicago.edu)
- *
- * Copyright (C) 1998-2000.  The University of Chicago
- * Copyright (C) 1995-1998.  The University of Utah and The Regents of the
- *                           University of California.
- *
- * See the file LICENSE for information on usage and redistribution.	
- * ----------------------------------------------------------------------------- */
-
-#include "internal.h"
-extern "C" {
-#include "doh.h"
-}
-
-static char cvsroot[] = "$Header$";
-
-Hash::Hash() {
-  data = NewHash();
-}
-
-Hash::~Hash() {
-  Delete(data);
-}
-
-int Hash::add(const char *k, void *obj) {
-  DOH *v = NewVoid(obj,0);
-  if (Getattr(data, (DOH *) k)) return -1;
-  Setattr(data, (DOH *) k, v);
-  return 0;
-}
-
-int Hash::add(const char *k, void *obj, void (*d)(void *)) {
-  DOH *v = NewVoid(obj,d);
-  if (Getattr(data, (DOH *) k)) return -1;
-  Setattr(data, (DOH *) k, v);
-  return 0;
-}
-
-void *Hash::lookup(const char *k) {
-  DOH *v;
-  v = Getattr(data,(DOH *)k);
-  if (!v) return 0;
-  return Data(v);
-}
-
-void Hash::remove(const char *k) {
-  Delattr(data,(DOH *)k);
-}
-
-void *Hash::first() {
-  DOH *o;
-  DOH *v = Firstkey(data);
-  if (v) {
-    o = Getattr(data,v);
-    return Data(o);
-  }
-  return 0;
-}
-
-char *Hash::firstkey() {
-  DOH *v = Firstkey(data);
-  if (v) {
-    return Char(v);
-  }
-  return 0;
-}
-
-void *Hash::next() {
-  DOH *o;
-  DOH *v = Nextkey(data);
-  if (v) {
-    o = Getattr(data,v);
-    return Data(o);
-  }
-  return 0;
-}
-
-char *Hash::nextkey() {
-  DOH *v = Nextkey(data);
-  if (v) {
-    return Char(v);
-  }
-  return 0;
-}
-

SWIG/Source/SWIG1.1/lang.cxx

@@ -21,6 +21,8 @@ extern "C" {
 #include "swig.h"
 }
 
+extern int add_symbol(char *name);
+
 // -----------------------------------------------------------------
 // void Language::set_init(char *iname)
 //
@@ -169,7 +171,7 @@ void Language::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l
 
   // Now do a symbol table lookup on it :
 
-  if (add_symbol(new_name, 0,0)) {
+  if (add_symbol(new_name)) {
     fprintf(stderr,"%s : Line %d. Function %s (member %s) multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, cname, name);
     return;
@@ -212,7 +214,7 @@ void Language::cpp_constructor(char *name, char *iname, ParmList *l) {
 
   // Add this function to the SWIG symbol table
 
-  if (add_symbol(cname, 0,0)) {
+  if (add_symbol(cname)) {
     fprintf(stderr,"%s : Line %d. Constructor %s multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, cname);
     return;
@@ -246,7 +248,7 @@ void Language::cpp_destructor(char *name, char *iname) {
 
   // Add this function to the SWIG symbol table
 
-  if (add_symbol(cname, 0,0)) {
+  if (add_symbol(cname)) {
     fprintf(stderr,"%s : Line %d. Destructor %s multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, cname);
     return;
@@ -324,7 +326,7 @@ void Language::cpp_variable(char *name, char *iname, DataType *t) {
 
   // Check the symbol table
 
-  if (add_symbol(cname,(DataType *) 0,(char *) 0)) {
+  if (add_symbol(cname)) {
     fprintf(stderr,"%s : Line %d. Variable %s multiply defined (2nd definition ignored).\n", input_file, line_number, cname);
     return;
   }
@@ -377,7 +379,7 @@ void Language::cpp_static_func(char *name, char *iname, DataType *t, ParmList *l
 
   // Now do a symbol table lookup on it :
 
-  if (add_symbol(cname, 0,0)) {
+  if (add_symbol(cname)) {
     if (ObjCClass)
       fprintf(stderr,"%s : Line %d. class function %s multiply defined (2nd definition ignored).\n",
 	      input_file, line_number, cname);
@@ -428,7 +430,7 @@ void Language::cpp_declare_const(char *name, char *iname, DataType *type, char *
 
   // Now do a symbol table lookup on it :
 
-  if (add_symbol(cname, 0,0)) {
+  if (add_symbol(cname)) {
     fprintf(stderr,"%s : Line %d. Constant %s (member %s) multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, cname, name);
     return;
@@ -488,7 +490,7 @@ void Language::cpp_static_var(char *name, char *iname, DataType *t) {
 
   // Now do a symbol table lookup on it :
 
-  if (add_symbol(cname, 0,0)) {
+  if (add_symbol(cname)) {
     fprintf(stderr,"%s : Line %d. Variable %s (member %s) multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, cname, name);
     return;

SWIG/Source/SWIG1.1/main.cxx

@@ -147,6 +147,7 @@ int SWIG_main(int argc, char *argv[], Language *l) {
   int     includecount = 0;
   extern  int check_suffix(char *);
   extern  void scanner_file(FILE *);
+  extern  void typemap_initialize(void);
   DOH    *libfiles = 0;
 
 #ifdef MACSWIG
@@ -155,7 +156,7 @@ int SWIG_main(int argc, char *argv[], Language *l) {
 
   // Initialize the preprocessor
   Preprocessor_init();
-
+  typemap_initialize();
   f_wrappers = 0;
   f_init = 0;
   f_header = 0;

SWIG/Source/SWIG1.1/parser.yxx

@@ -76,10 +76,12 @@ static String         ArrayBackup;             // Array backup string
 static char           *DefArg = 0;             // Default argument hack
 static char           *ConstChar = 0;          // Used to store raw character constants
 static ParmList       *tm_parm = 0;            // Parameter list used to hold typemap parameters
-static Hash            name_hash;              // Hash table containing renamings
+static DOHHash        *name_hash = 0;          // Hash table containing renamings
        char           *objc_construct = (char *) "new"; // Objective-C constructor
        char           *objc_destruct = (char *) "free"; // Objective-C destructor
 
+static DOHHash        *symbols = 0; 
+
 /* Some macros for building constants */
 
 #define E_BINARY(TARGET, SRC1, SRC2, OP)  \
@@ -129,6 +131,14 @@ static void init_language() {
   lang_init = 1;
 }
 
+/* Add a symbol to the symbol table. Return -1 if it already exists */
+int add_symbol(char *name) {
+   if (!symbols) symbols = NewHash();
+   if (Getattr(symbols,name)) return -1;
+   Setattr(symbols,name,name);
+   return 0;
+}
+
 // ----------------------------------------------------------------------
 // int promote(int t1, int t2)
 //
@@ -160,7 +170,9 @@ int promote(int t1, int t2) {
 
 static char *make_name(char *name) {
   // Check to see if the name is in the hash
-  char *nn = (char *) name_hash.lookup(name);
+  if (!name_hash) name_hash = NewHash();
+  char *nn = GetChar(name_hash,name);
+
   if (nn) return nn;        // Yep, return it.
 
   if (Rename_true) {
@@ -197,7 +209,7 @@ void create_function(int ext, char *name, DataType *t, ParmList *l) {
 
   // Check if symbol already exists
 
-  if (add_symbol(iname, t, (char *) 0)) {
+  if (add_symbol(iname)) {
     fprintf(stderr,"%s : Line %d. Function %s multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, iname);
   } else {
@@ -232,7 +244,7 @@ void create_variable(int ext, char *name, DataType *t) {
   init_language();
 
   char *iname = make_name(name);
-  if (add_symbol(iname, t, (char *) 0)) {
+  if (add_symbol(iname)) {
     fprintf(stderr,"%s : Line %d. Variable %s multiply defined (2nd definition ignored).\n",
 	    input_file, line_number, iname);
   } else {
@@ -278,13 +290,10 @@ void create_constant(char *name, DataType *type, char *value) {
   
   if (!value) value = copy_string(name);
   sprintf(temp_name,"const:%s", name);
-  if (add_symbol(temp_name, type, value)) {
+  if (add_symbol(temp_name)) {
     fprintf(stderr,"%s : Line %d. Constant %s multiply defined. (2nd definition ignored)\n",
 	    input_file, line_number, name);
   } else {
-    // Update symbols value if already defined.
-    update_symbol(name, type, value);
-
     if (!WrapExtern) {    // Only wrap the constant if not in %extern mode
       lang->declare_const(name, name, type, value);
     }
@@ -685,10 +694,8 @@ statement      : INCLUDE STRING LBRACE {
 
 /* %rename directive */
                | RENAME ID ID SEMI { 
-		 if (name_hash.lookup($2)) {
+		 if (!name_hash) name_hash = NewHash();
-		   name_hash.remove($2);
+		 Setattr(name_hash,$2,$3);
-		 }
-		 name_hash.add($2,copy_string($3));
 	       }
           
 /* %new directive */
@@ -714,7 +721,7 @@ statement      : INCLUDE STRING LBRACE {
                | NATIVE LPAREN ID RPAREN extern ID SEMI {
 		 if (!WrapExtern) {
 		   init_language();
-		   if (add_symbol($3,(DataType *) 0, (char *) 0)) {
+		   if (add_symbol($3)) {
 		     fprintf(stderr,"%s : Line %d. Name of native function %s conflicts with previous declaration (ignored)\n",
 			     input_file, line_number, $3);
 		   } else {
@@ -726,7 +733,7 @@ statement      : INCLUDE STRING LBRACE {
 		 if (!WrapExtern) {
 		   init_language();
 		   $6->is_pointer += $7.is_pointer;
-		   if (add_symbol($3,(DataType *) 0, (char *) 0)) {
+		   if (add_symbol($3)) {
 		     fprintf(stderr,"%s : Line %d. Name of native function %s conflicts with previous declaration (ignored)\n",
 			     input_file, line_number, $3);
 		   } else {
@@ -877,7 +884,7 @@ statement      : INCLUDE STRING LBRACE {
 		     delete temp_typeptr;
 		   } else if ($3.type == T_SYMBOL) {
 		     // Add a symbol to the SWIG symbol table
-		     if (add_symbol($2,(DataType *) 0, (char *) 0)) {
+		     if (add_symbol($2)) {
 		       fprintf(stderr,"%s : Line %d. Warning. Symbol %s already defined.\n", 
 			       input_file,line_number, $2);
 		     }
@@ -1843,16 +1850,8 @@ expr           :  NUM_INT {
 		  $$.type = $2->type;
 	       } 
                | ID {
-		 $$.id = lookup_symvalue($1);
+		 $$.id = $1;
-		 if ($$.id == (char *) 0)
+		 $$.type = T_INT;
-		   $$.id = $1;
-		 else {
-		   $$.id = new char[strlen($$.id)+3];
-		   sprintf($$.id,"(%s)",lookup_symvalue($1));
-		 }
-		 temp_typeptr = lookup_symtype($1);
-		 if (temp_typeptr) $$.type = temp_typeptr->type;
-		 else $$.type = T_INT;
                }
                | ID DCOLON ID {
                   $$.id = new char[strlen($1)+strlen($3)+3];
@@ -1987,7 +1986,7 @@ cpp_class    :
 	       DataType::new_scope();
 	       
 	       sprintf(temp_name,"CPP_CLASS:%s\n",$3);
-	       if (add_symbol(temp_name, (DataType *) 0, (char *) 0)) {
+	       if (add_symbol(temp_name)) {
 		 fprintf(stderr,"%s : Line %d. Error. %s %s is multiply defined.\n", input_file, line_number, $2, $3);
 		 FatalError();
 	       }
@@ -2042,7 +2041,7 @@ cpp_class    :
 	       DataType::new_scope();
 	       
 	       sprintf(temp_name,"CPP_CLASS:%s\n",$3);
-	       if (add_symbol(temp_name, (DataType *) 0, (char *) 0)) {
+	       if (add_symbol(temp_name)) {
 		 fprintf(stderr,"%s : Line %d. Error. %s %s is multiply defined.\n", input_file, line_number, $2, $3);
 		 FatalError();
 	       }
@@ -2147,7 +2146,7 @@ cpp_class    :
 		  cplus_abort();
 		} else {
 		  sprintf(temp_name,"CPP_CLASS:%s\n",$7.id);
-		  if (add_symbol(temp_name, (DataType *) 0, (char *) 0)) {
+		  if (add_symbol(temp_name)) {
 		    fprintf(stderr,"%s : Line %d. Error. %s %s is multiply defined.\n", input_file, line_number, $2, $7.id);
 		    FatalError();
 		  }
@@ -2855,7 +2854,7 @@ objective_c    : OC_INTERFACE ID objc_inherit {
                    init_language();
 		   cplus_mode = CPLUS_PROTECTED;
 		   sprintf(temp_name,"CPP_CLASS:%s\n",$2);
-		   if (add_symbol(temp_name,(DataType *) 0, (char *) 0)) {
+		   if (add_symbol(temp_name)) {
 		     fprintf(stderr,"%s : Line %d.  @interface %s is multiple defined.\n",
 			     input_file,line_number,$2);
 		     FatalError();

SWIG/Source/SWIG1.1/scanner.cxx

@@ -123,7 +123,6 @@ void scanner_close() {
     line_number = p->line_number;
     input_file = p->in_file;
     WrapExtern = p->extern_mode;
-    if (!WrapExtern) remove_symbol((char*)"SWIGEXTERN");
     ForceExtern = p->force_extern;
   } else {
     LEX_in = NULL;

SWIG/Source/SWIG1.1/swig11.h

@@ -100,26 +100,6 @@ public:
 #define  endl   "\n"
 #define  quote  "\""
 
-// -------------------------------------------------------------------
-// Hash table class
-// -------------------------------------------------------------------
-
-class Hash {
-private:
-  void  *data;
-public:
-  Hash();
-  ~Hash();
-  int    add(const char *key, void *object);
-  int    add(const char *key, void *object, void (*del)(void *));
-  void  *lookup(const char *key);
-  void   remove(const char *key);
-  void  *first();
-  void  *next();
-  char  *firstkey();
-  char  *nextkey();
-};
-
 /************************************************************************
  * class DataType
  *
@@ -424,16 +404,11 @@ public:
 
 extern  void  emit_extern_var(char *, DataType *, int, FILE *);
 extern  void  emit_extern_func(char *, DataType *, ParmList *, int, FILE *);
-extern  int   emit_args(DataType *, ParmList *, FILE *);
-
 extern  void  emit_func_call(char *, DataType *, ParmList *, FILE *);
 
-extern  void  emit_hex(FILE *);
 extern  void  emit_set_get(char *, char *, DataType *);
-extern  void  emit_banner(FILE *);
 extern  void  emit_ptr_equivalence(FILE *);
 extern  int   SWIG_main(int, char **, Language *);
-extern  void  make_wrap_name(char *);
 
 // Some functions for emitting some C++ helper code
 
@@ -472,7 +447,6 @@ extern "C" {
   extern FILE *Swig_open(const void *filename);
 }
 
-
 // -----------------------------------------------------------------------
 //  Class for Creating Wrapper Functions
 // -----------------------------------------------------------------------
@@ -499,15 +473,6 @@ extern  int   emit_args(DataType *, ParmList *, WrapperFunction &f);
 extern  void  emit_func_call(char *, DataType *, ParmList *, WrapperFunction &f);
 extern  void  SWIG_exit(int);
 
-// Symbol table management
-
-extern int  add_symbol(char *, DataType *, char *);
-extern void remove_symbol(char *);
-extern int  update_symbol(char *, DataType *, char *);
-extern char *lookup_symvalue(char *);
-extern DataType *lookup_symtype(char *);
-extern int  lookup_symbol(char *);
-
 // -----------------------------------------------------------------------
 // Typemap support
 // -----------------------------------------------------------------------
@@ -535,16 +500,7 @@ extern void    fragment_clear(char *op, char *lang);
 
 extern  void  emit_ptr_equivalence(WrapperFunction &);
 
-// -----------------------------------------------------------------------
-// Naming system
-// -----------------------------------------------------------------------
 
-#define AS_IS      1
 
-extern void   name_register(char *method, char *format);
+
-extern char  *name_wrapper(char *fname, char *prefix, int suppress=0);
+
-extern char  *name_member(char *fname, char *classname, int suppress=0);
-extern char  *name_get(char *vname, int suppress=0);
-extern char  *name_set(char *vname, int suppress=0);
-extern char  *name_construct(char *classname, int suppress=0);
-extern char  *name_destroy(char *classname, int suppress=0);

SWIG/Source/SWIG1.1/symbol.cxx

@@ -1,146 +0,0 @@
-/* ----------------------------------------------------------------------------- 
- * symbol.cxx
- *
- *     Symbol table management.
- * 
- * Author(s) : David Beazley (beazley@cs.uchicago.edu)
- *
- * Copyright (C) 1998-2000.  The University of Chicago
- * Copyright (C) 1995-1998.  The University of Utah and The Regents of the
- *                           University of California.
- *
- * See the file LICENSE for information on usage and redistribution.	
- * ----------------------------------------------------------------------------- */
-
-#include "internal.h"
-
-static char cvstag[] = "$Header$";
-
-// -----------------------------------------------------------------------------
-// Symbol object
-// -----------------------------------------------------------------------------
-
-struct   Symbol {
-  ~Symbol() {
-    if (name) delete name;
-    if (type) delete type;
-    if (value) delete value;
-  }
-  char      *name;
-  DataType  *type;        // Optional datatype
-  char      *value;       // Optional value (for constant expressions)
-};
-
-static Hash    SymHash;   // SWIG Symbol table
-
-// -----------------------------------------------------------------------------
-// int add_symbol(char *name, DataType *type, char *value)
-// 
-// Adds a symbol to the symbol table. Returns -1 if symbol is already in the table.
-// -----------------------------------------------------------------------------
-
-int add_symbol(char *name, DataType *type, char *value) {
-
-  Symbol *s;
-  int ret;
-  
-  s = new Symbol;
-  s->name = copy_string(name);
-  if (type)
-    s->type = new DataType(type);
-  else s->type = (DataType *) 0;
-  if (value) 
-    s->value = copy_string(value);
-  else s->value = (char *) 0;
-
-  // Add this to the symbol table
-
-  ret = SymHash.add(s->name, s);
-  if (ret == -1) {
-    delete s;
-  } 
-  return ret;
-}
-
-// -----------------------------------------------------------------------------
-// int lookup_symbol(char *name)
-// 
-// Checks to see if a symbol is in the symbol table.
-// -----------------------------------------------------------------------------
-
-int lookup_symbol(char *name) {
-  Symbol *s;
-
-  s = (Symbol *) SymHash.lookup(name);
-  if (s) return 1;
-  else return 0;
-}
-
-// -----------------------------------------------------------------------------
-// DataType *lookup_symtype(char *name)
-// 
-// Returns the datatype of a symbol or NULL if not found.
-// -----------------------------------------------------------------------------
-
-DataType *lookup_symtype(char *name) {
-
-  Symbol *s;
-
-  s = (Symbol *) SymHash.lookup(name);
-  if (s) return s->type;
-  else return (DataType *) 0;
-}
-
-// -----------------------------------------------------------------------------
-// char *lookup_symvalue(char *name)
-// 
-// Returns the value associate with a symbol.
-// -----------------------------------------------------------------------------
-
-char *lookup_symvalue(char *name) {
-
-  Symbol *s;
-
-  s = (Symbol *) SymHash.lookup(name);
-  if (s) return s->value;
-  else return (char *) 0;
-}
-
-// -----------------------------------------------------------------------------
-// int update_symbol(char *name, DataType *type, char *value)
-//
-// Updates a symbol (or create it) in the hash table.
-// -----------------------------------------------------------------------------
-
-int update_symbol(char *name, DataType *type, char *value) {
-
-  Symbol *s;
-
-  s = (Symbol *) SymHash.lookup(name);
-  if (s) {
-    if (s->type) delete s->type;
-    if (s->value) delete s->value;
-    if (type) 
-      s->type = new DataType(type);
-    else
-      s->type = (DataType *) 0;
-    if (value) 
-      s->value = copy_string(value);
-    else
-      s->value = (char *) 0;
-    return 0;
-  } else {
-    return add_symbol(name, type, value);
-  }
-}
-
-// -----------------------------------------------------------------------------
-// void remove_symbol(char *name)
-// 
-// Removes a symbol from the symbol table.
-// -----------------------------------------------------------------------------
-
-void remove_symbol(char *name) {
-  SymHash.remove(name);
-}
-

SWIG/Source/SWIG1.1/typemap.cxx

@@ -17,6 +17,10 @@ static char cvsroot[] = "$Header$";
 #include "internal.h"
 #include <limits.h>
 
+extern "C" {
+#include "doh.h"
+}
+
 // ------------------------------------------------------------------------
 // This file provides universal support for typemaps.   Typemaps are created
 // using the following SWIG command in an interface file:
@@ -127,7 +131,7 @@ struct TypeMap {
 
 // Hash tables for storing type-mappings
 
-static Hash  typemap_hash;
+static DOH *typemap_hash = 0;
 
 // Structure for holding "applications of a typemap"
 
@@ -149,7 +153,7 @@ struct TmMethod {
 
 // Hash table for storing applications of a datatype
 
-static Hash application_hash;
+static DOH *application_hash = 0;
 
 // ------------------------------------------------------------------------
 // void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname)
@@ -168,11 +172,12 @@ void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname
 
   // See if there is a method already defined
 
-  m = (TmMethod *) application_hash.lookup(temp);
+  if (!application_hash) application_hash = NewHash();
+  m = (TmMethod *) GetVoid(application_hash,temp);
   
   if (!m) {
     m = new TmMethod(temp,type,0);
-    application_hash.add(temp,m);
+    SetVoid(application_hash,temp,m);
   }
 
   // Check to see if an array typemap has been applied to a non-array type
@@ -219,7 +224,8 @@ void typemap_clear_apply(DataType *type, char *pname) {
   char temp[512];
   if (!pname) pname = (char*)"";
   sprintf(temp,"%s$%s", type->print_type(), pname);
-  application_hash.remove(temp);
+  if (!application_hash) application_hash = NewHash();
+  Delattr(application_hash,temp);
 }
 
 // ------------------------------------------------------------------------
@@ -263,6 +269,7 @@ void typemap_register(char *op, char *lang, DataType *type, char *pname,
 
   // printf("Registering : %s %s %s %s\n%s\n", op, lang, type->print_type(), pname, getcode);
 
+  if (!typemap_hash) typemap_hash = NewHash();
 
   tm = new TypeMap(lang,type,getcode,args);
   // If this is a default typemap, downgrade the type!
@@ -276,7 +283,7 @@ void typemap_register(char *op, char *lang, DataType *type, char *pname,
 
   // Get any previous setting of the typemap
 
-  tm_old = (TypeMap *) typemap_hash.lookup(key);
+  tm_old = (TypeMap *) GetVoid(typemap_hash,key);
 
   if (tm_old) {
 
@@ -296,11 +303,11 @@ void typemap_register(char *op, char *lang, DataType *type, char *pname,
 
     // Remove the old one from the hash
   
-    typemap_hash.remove(key);
+    Delattr(typemap_hash,key);
   } 
 
   // Add new typemap to the hash table
-  typemap_hash.add(key,(void *) tm);
+  SetVoid(typemap_hash,key,tm);
 
   // Now try to perform default chaining operation (if available)
   //  if (!is_default) {
@@ -390,7 +397,8 @@ TypeMap *typemap_search(char *key, int id) {
   
   TypeMap *tm;
 
-  tm = (TypeMap *) typemap_hash.lookup(key);
+  if (!typemap_hash) typemap_hash = NewHash();
+  tm = (TypeMap *) GetVoid(typemap_hash,key);
   while (tm) {
     if ((id >= tm->first) && (id < tm->last)) return tm;
     else tm = tm->next;
@@ -691,10 +699,10 @@ char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *so
       tstr = type->print_type();
       sprintf(temp,"%s$%s",tstr,ppname);
       // No mapping was found.  See if the name has been mapped with %apply
-      m = (TmMethod *) application_hash.lookup(temp);
+      m = (TmMethod *) GetVoid(application_hash,temp);
       if (!m) {
 	sprintf(temp,"%s$",tstr);
-	m = (TmMethod *) application_hash.lookup(temp);
+	m = (TmMethod *) GetVoid(application_hash,temp);
       }
       if (m) {
 	m = m->next;
@@ -847,10 +855,11 @@ char *typemap_check(char *op, char *lang, DataType *type, char *pname) {
       tstr = type->print_type();
       sprintf(temp,"%s$%s",tstr,ppname);
       // No mapping was found.  See if the name has been mapped with %apply
-      m = (TmMethod *) application_hash.lookup(temp);
+      if (!application_hash) application_hash = NewHash();
+      m = (TmMethod *) GetVoid(application_hash,temp);
       if (!m) {
 	sprintf(temp,"%s$",tstr);
-	m = (TmMethod *) application_hash.lookup(temp);
+	m = (TmMethod *) GetVoid(application_hash,temp);
       }
       if (m) {
 	m = m->next;
@@ -938,7 +947,8 @@ void typemap_clear(char *op, char *lang, DataType *type, char *pname) {
   // Look for any previous version, simply set the last id if
   // applicable.
   
-  tm = (TypeMap *) typemap_hash.lookup(key);
+  if (!typemap_hash) typemap_hash = NewHash();
+  tm = (TypeMap *) GetVoid(typemap_hash,key);
   if (tm) {
     if (tm->last > type_id) tm->last = type_id;
   }
@@ -968,8 +978,8 @@ void typemap_copy(char *op, char *lang, DataType *stype, char *sname,
     if (tk) {
       tn = new TypeMap(tk);       // Make a copy of the previous typemap
       tn->next = tm;              // Set up symlinks
-      typemap_hash.remove(key);   // Remove old hash entry
+      Delattr(typemap_hash,key);  // Remove old hash entry
-      typemap_hash.add(key,(void *) tn);
+      SetVoid(typemap_hash,key, tn);
     }
   } else {
     typemap_register(op,lang,ttype,tname,tm->code,tm->args);
@@ -1009,7 +1019,7 @@ void fragment_register(char *op, char *lang, char *code) {
 
   // Get any previous setting of the typemap
 
-  tm_old = (TypeMap *) typemap_hash.lookup(key);
+  tm_old = (TypeMap *) GetVoid(typemap_hash,key);
   if (tm_old) {
     // If found, we need to attach the old version to the new one
 
@@ -1024,7 +1034,7 @@ void fragment_register(char *op, char *lang, char *code) {
 
     // Remove the old one from the hash
   
-    typemap_hash.remove(key);
+    Delattr(typemap_hash,key);
   }
   
   // Perform a default chaining operation if needed (defaults to nothing)
@@ -1032,7 +1042,7 @@ void fragment_register(char *op, char *lang, char *code) {
   tm->code.replace(temp,"");
 
   // Add new typemap to the hash table
-  typemap_hash.add(key,(void *) tm);
+  SetVoid(typemap_hash,key,tm);
     
 }
 
@@ -1084,8 +1094,20 @@ void fragment_clear(char *op, char *lang) {
   // Look for any previous version, simply set the last id if
   // applicable.
   
-  tm = (TypeMap *) typemap_hash.lookup(key);
+  tm = (TypeMap *) GetVoid(typemap_hash,key);
   if (tm) {
     if (tm->last > type_id) tm->last = type_id;
   }
 }
+
+// -----------------------------------------------------------------------------
+// typemap_initialize()
+//
+// Initialize the hash tables
+// -----------------------------------------------------------------------------
+
+void
+typemap_initialize() {
+  typemap_hash = NewHash();
+  application_hash = NewHash();
+}

SWIG/Source/SWIG1.1/types.cxx

@@ -16,6 +16,10 @@ static char cvsroot[] = "$Header$";
 
 #include "internal.h"
 
+extern "C" {
+#include "doh.h"
+}
+
 // -------------------------------------------------------------------
 // class DataType member functions.
 // -------------------------------------------------------------------
@@ -430,7 +434,7 @@ char *DataType::get_array() {
 // typedef support.  This needs to be scoped.
 // --------------------------------------------------------------------
 
-static Hash *typedef_hash[MAXSCOPE];
+static DOHHash *typedef_hash[MAXSCOPE];
 static int   scope = 0;            // Current scope
 
 // -----------------------------------------------------------------------------
@@ -449,7 +453,7 @@ void DataType::init_typedef() {
     typedef_hash[i] = 0;
   scope = 0;
   // Create a new hash
-  typedef_hash[scope] = new Hash;
+  typedef_hash[scope] = NewHash();
 }
 
 // --------------------------------------------------------------------
@@ -471,7 +475,7 @@ void DataType::typedef_add(char *tname, int mode) {
   // We only check in the local scope.   C++ classes may make typedefs
   // that shadow global ones.
 
-  if (typedef_hash[scope]->lookup(tname)) {
+  if (Getattr(typedef_hash[scope],tname)) {
     fprintf(stderr,"%s : Line %d. Warning. Datatype %s already defined (2nd definition ignored).\n",
 	    input_file, line_number, tname);
       return;
@@ -486,7 +490,7 @@ void DataType::typedef_add(char *tname, int mode) {
   //  strcpy(nt->name,tname);              // Copy over the new name
   
   // Add this type to our hash table
-  typedef_hash[scope]->add(tname,(void *) nt);
+  SetVoid(typedef_hash[scope],tname, (void *) nt);
 
   // Now add this type mapping to our type-equivalence table
 
@@ -534,7 +538,7 @@ void DataType::typedef_resolve(int level) {
   int       s = scope - level;
 
   while (s >= 0) {
-    if ((td = (DataType *) typedef_hash[s]->lookup(name))) {
+    if ((td = (DataType *) GetVoid(typedef_hash[s],name))) {
       type = td->type;
       is_pointer += td->is_pointer;
       implicit_ptr += td->implicit_ptr;
@@ -568,7 +572,7 @@ void DataType::typedef_replace () {
   DataType *td;
   String temp;
 
-  if ((td = (DataType *) typedef_hash[scope]->lookup(name))) {
+  if ((td = (DataType *) GetVoid(typedef_hash[scope],name))) {
     type = td->type;
     is_pointer = td->is_pointer;
     implicit_ptr -= td->implicit_ptr;
@@ -596,7 +600,7 @@ void DataType::typedef_replace () {
 int DataType::is_typedef(char *t) {
   int s = scope;
   while (s >= 0) {
-    if (typedef_hash[s]->lookup(t)) return 1;
+    if (Getattr(typedef_hash[s],t)) return 1;
     s--;
   }
   return 0;
@@ -613,7 +617,7 @@ int DataType::is_typedef(char *t) {
 void DataType::typedef_updatestatus(int newstatus) {
 
   DataType *t;
-  if ((t = (DataType *) typedef_hash[scope]->lookup(name))) {
+  if ((t = (DataType *) GetVoid(typedef_hash[scope],name))) {
     t->status = newstatus;
   }
 }
@@ -633,19 +637,19 @@ void DataType::typedef_updatestatus(int newstatus) {
 // -----------------------------------------------------------------------------
 
 void DataType::merge_scope(void *ho) {
-  char  *key;
+  DOHString *key;
   DataType *t, *nt;
-  Hash *h = (Hash *) ho;
+  DOHHash *h = (DOHHash *) ho;
 
   if (h) {
     // Copy all of the entries in the given hash table to this new one
-    key = h->firstkey();
+    key = Firstkey(h);
     while (key) {
       //      printf("%s\n", key);
-      t = (DataType *) h->lookup(key);
+      t = (DataType *) GetVoid(h,key);
       nt = new DataType(t);
-      typedef_hash[scope]->add(key,(void *) nt);
+      SetVoid(typedef_hash[scope],key,(void *) nt);
-      key = h->nextkey();
+      key = Nextkey(h);
     }
   }
 }
@@ -664,12 +668,10 @@ void DataType::merge_scope(void *ho) {
 // -----------------------------------------------------------------------------
 
 void DataType::new_scope(void *ho) {
-  Hash *h = (Hash *) ho;
   scope++;
-  typedef_hash[scope] = new Hash;
+  typedef_hash[scope] = NewHash();
-
+  if (ho) {
-  if (h) {
+    merge_scope(ho);
-    merge_scope(h);
   }
 }
 
@@ -697,22 +699,22 @@ void DataType::new_scope(void *ho) {
 
 void *DataType::collapse_scope(char *prefix) {
   DataType *t,*nt;
-  char     *key;
+  DOHString *key;
   char     *temp;
-  Hash     *h;
+  DOHHash  *h;
 
   if (scope > 0) {
     if (prefix) {
-      key = typedef_hash[scope]->firstkey();
+      key = Firstkey(typedef_hash[scope]);
       while (key) {
-	t = (DataType *) typedef_hash[scope]->lookup(key);
+	t = (DataType *) GetVoid(typedef_hash[scope],key);
 	nt = new DataType(t);
-	temp = new char[strlen(prefix)+strlen(key)+3];
+	temp = new char[strlen(prefix)+strlen(Char(key))+3];
-	sprintf(temp,"%s::%s",prefix,key);
+	sprintf(temp,"%s::%s",prefix,Char(key));
 	//	printf("creating %s\n", temp);
-	typedef_hash[scope-1]->add(temp,(void *) nt);
+	SetVoid(typedef_hash[scope-1],temp, (void *)nt);
 	delete temp;
-	key = typedef_hash[scope]->nextkey();
+	key = Nextkey(typedef_hash[scope]);
       }
     }
     h = typedef_hash[scope];
@@ -740,11 +742,12 @@ struct EqEntry {
   EqEntry  *next;
 };
 
-static Hash typeeq_hash;
+static DOHHash *typeeq_hash = 0;
 static int  te_init = 0;
 
 void typeeq_init() {
   void typeeq_standard();
+  if (!typeeq_hash) typeeq_hash = NewHash();
   te_init = 1;
   typeeq_standard();
 }
@@ -768,7 +771,7 @@ void typeeq_add(char *name, char *eqname, char *cast = 0, DataType *type = 0) {
   
   // Search for "name" entry in the hash table
 
-  e1 = (EqEntry *) typeeq_hash.lookup(name);
+  e1 = (EqEntry *) GetVoid(typeeq_hash,name);
 
   if (!e1) {
     // Create a new entry
@@ -777,7 +780,7 @@ void typeeq_add(char *name, char *eqname, char *cast = 0, DataType *type = 0) {
     e1->next = 0;
     e1->cast = 0;
     // Add it to the hash table
-    typeeq_hash.add(name,(void *) e1);
+    SetVoid(typeeq_hash,name,(void *) e1);
   }
 
   // Add new type to the list
@@ -829,7 +832,7 @@ void typeeq_addtypedef(char *name, char *eqname, DataType *t) {
 
   // Now find the hash entry
 
-  e1 = (EqEntry *) typeeq_hash.lookup(name);
+  e1 = (EqEntry *) GetVoid(typeeq_hash,name);
   if (!e1) return;
 
   // Walk down the list and make other equivalences
@@ -856,6 +859,7 @@ void typeeq_addtypedef(char *name, char *eqname, DataType *t) {
 void emit_ptr_equivalence(FILE *f) {
 
   EqEntry  *e1,*e2;
+  DOH      *k;
   void     typeeq_standard();
   String   ttable;
 
@@ -867,8 +871,9 @@ void emit_ptr_equivalence(FILE *f) {
  */\n\
 static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {\n";
 
-  e1 = (EqEntry *) typeeq_hash.first();
+  k = Firstkey(typeeq_hash);
-  while (e1) {
+  while (k) {
+    e1 = (EqEntry *) GetVoid(typeeq_hash,k);
     e2 = e1->next;
     // Walk through the equivalency list
     while (e2) {
@@ -878,7 +883,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
 	ttable << tab4 << "{ \"" << e1->name << "\",\"" << e2->name << "\",0},\n";
       e2 = e2->next;
     }
-    e1 = (EqEntry *) typeeq_hash.next();
+    k = Nextkey(typeeq_hash);
   }
   ttable << "{0,0,0}};\n";
   fprintf(f_wrappers,"%s\n", ttable.get());
@@ -895,8 +900,9 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
 	 << "    void *(*convert)(void *);\n"
 	 << "} SwigType;\n";
 
-  e1 = (EqEntry *) typeeq_hash.first();
+  k = Firstkey(typeeq_hash);
-  while (e1) {
+  while (k) {
+    e1 = (EqEntry *) GetVoid(typeeq_hash,k);
     e2 = e1->next;
     ctable << "static SwigType " << e1->name << "[] = {";
     // Walk through the equivalency list
@@ -909,7 +915,7 @@ static struct { char *n1; char *n2; void *(*pcnv)(void *); } _swig_mapping[] = {
       e2 = e2->next;
     }
     ctable << "{0,0}};\n";
-    e1 = (EqEntry *) typeeq_hash.next();
+    k = Nextkey(typeeq_hash);
   }
   ctable << "*/\n";
   fprintf(f_wrappers,"%s\n", ctable.get());
@@ -993,14 +999,17 @@ check_equivalent(DataType *t) {
   static String out;
   int    npointer = t->is_pointer;
   String m;
+  DOH   *k;
 
   out = "";
   while (t->is_pointer >= t->implicit_ptr) {
     m = t->print_mangle();
 
     if (!te_init) typeeq_init();
-    e1 = (EqEntry *) typeeq_hash.first();
+
-    while (e1) {
+    k = Firstkey(typeeq_hash);
+    while (k) {
+      e1 = (EqEntry *) GetVoid(typeeq_hash,k);
       /*      printf("'%s', '%s'\n", m.get(),e1->name); */
       if (strcmp(m.get(),e1->name) == 0) {
 	e2 = e1->next;
@@ -1017,7 +1026,7 @@ check_equivalent(DataType *t) {
 	  e2 = e2->next;
 	}
       }
-      e1 = (EqEntry *) typeeq_hash.next();
+      k = Nextkey(typeeq_hash);
     }
     t->is_pointer--;
   }
@@ -1033,19 +1042,19 @@ check_equivalent(DataType *t) {
 // work across multiple files.
 // -----------------------------------------------------------------------------
 
-static Hash  bases;
+static DOHHash  *bases = 0;
 
 void DataType::record_base(char *derived, char *base)
 {
-  Hash *nh;
+  DOHHash *nh;
-  nh = (Hash *) bases.lookup(derived);
+  if (!bases) bases = NewHash();
+  nh = Getattr(bases,derived);
   if (!nh) {
-    nh = new Hash();
+    nh = NewHash();
-    bases.add(derived, (void *) nh);
+    Setattr(bases,derived,nh);
   }
-  if (!nh->lookup(base)) {
+  if (!Getattr(nh,base)) {
-    char *bn = copy_string(base);
+    Setattr(nh,base,base);
-    nh->add(base,(void *) bn);
   }
 }
 
@@ -1056,46 +1065,51 @@ void DataType::record_base(char *derived, char *base)
 // construct a big table of pointer values at the end.
 // ----------------------------------------------------------------------
 
-static  Hash  remembered;
+static  DOHHash  *remembered = 0;
 
 void DataType::remember() {
-  Hash *h;
+  DOHHash *h;
   DataType *t = new DataType(this);
-  remembered.add(t->print_mangle(),(void *) t);
 
+  if (!remembered) remembered = NewHash();
+  SetVoid(remembered, t->print_mangle(), t);
+
+  if (!bases) bases = NewHash();
   /* Now, do the base-class hack */
-  h = (Hash *) bases.lookup(t->name);
+  h = Getattr(bases,t->name);
   if (h) {
-    char *key;
+    DOH *key;
-    key = h->firstkey();
+    key = Firstkey(h);
     while (key) {
       DataType *nt = new DataType(t);
-      strcpy(nt->name,key);
+      strcpy(nt->name,Char(key));
-      if (!remembered.lookup(nt->print_mangle()))
+      if (!Getattr(remembered,nt->print_mangle())) 
 	nt->remember();
       delete nt;
-      key = h->nextkey();
+      key = Nextkey(h);
     }
   }
 }
 
 void
 emit_type_table() {
-  char *key;
+  DOH *key;
   String types, table;
   int i = 0;
 
+  if (!remembered) remembered = NewHash();
+
   table << "static _swig_type_info *_swig_types_initial[] = {\n";
-  key = remembered.firstkey();
+  key = Firstkey(remembered);
   fprintf(f_runtime,"/* ---- TYPES TABLE (BEGIN) ---- */\n");
   while (key) {
-    fprintf(f_runtime,"#define  SWIGTYPE%s _swig_types[%d] \n", key, i);
+    fprintf(f_runtime,"#define  SWIGTYPE%s _swig_types[%d] \n", Char(key), i);
-    types << "static _swig_type_info _swigt_" << key << "[] = {";
+    types << "static _swig_type_info _swigt_" << Char(key) << "[] = {";
-    types << "{\"" << key << "\",0},";
+    types << "{\"" << Char(key) << "\",0},";
-    types << "{\"" << key << "\",0},";
+    types << "{\"" << Char(key) << "\",0},";
-    types << check_equivalent((DataType *)remembered.lookup(key)) << "};\n";
+    types << check_equivalent((DataType *)GetVoid(remembered,key)) << "};\n";
-    table << "_swigt_" << key << ", \n";
+    table << "_swigt_" << Char(key) << ", \n";
-    key = remembered.nextkey();
+    key = Nextkey(remembered);
     i++;
   }
 

SWIG/Source/Swig/misc.c

@@ -53,6 +53,7 @@ Swig_banner(DOHFile *f) {
  * changes to this file unless you know what you are doing--modify the SWIG \n\
  * interface file instead. \n\
  * ----------------------------------------------------------------------------- */\n\n", SWIG_VERSION, SWIG_SPIN);
+
 }