diff --git a/SWIG/Source/Swig/super.c b/SWIG/Source/Swig/super.c
new file mode 100644
index 000000000..899bfc22d
--- /dev/null
+++ b/SWIG/Source/Swig/super.c
@@ -0,0 +1,855 @@
+# ----------------------------------------------------------------------
+# Simplified Wrapper and Interface Generator (SWIG)
+# 
+# Authors : David Beazley
+#           Dustin Mitchell  
+#
+# Department of Computer Science        
+# University of Chicago
+# 1100 E 58th Street
+# Chicago, IL  60637
+# beazley@cs.uchicago.edu
+#
+# Please read the file LICENSE for the copyright and terms by which SWIG
+# can be used and distributed.
+# ----------------------------------------------------------------------
+
+#include "doh.h"
+#include "swigcore.h"
+
+#if 0
+/*
+ * SuperStrings are just like strings, except that they maintain
+ * information as to the origininal file/line of each character they
+ * contain.
+ */
+
+typedef struct SSTag {
+  int position;
+  int line;
+  DOH *filename;
+} SSTag;
+
+typedef struct Super {
+  DOHCOMMON;
+
+  /* -- from the regular string implementation */
+  int maxsize;			/* Max size allocated */
+  int len;			/* Current length     */
+  int hashkey;			/* Hash key value     */
+  int sp;			/* Current position   */
+  int lsp;			/* Last returned position */
+  char *str;			/* String data        */
+  char pb[4];			/* Pushback data      */
+  int pbi;
+
+  /* -- specific to the SuperString implementation */
+  SSTag *tags;			/* array of tags */
+  int maxtags;			/* max size allocated for tags */
+  int numtags;			/* count of tags */
+} Super;
+
+/* Forward references for member functions */
+
+static void DelSuper(DOH *s);
+static DOH *CopySuper(DOH *s);
+static void Super_clear(DOH *s);
+static DOH *Super_str(DOH *s);
+static int Super_delitem(DOH *s, int where);
+static int Super_len(DOH *s);
+static void Super_appendfv(DOH *s, char *fmt, va_list ap);
+static int Super_insertfv(DOH *s, int pos, char *fmt, va_list ap);
+static int Super_insert(DOH *s, int pos, DOH *DOH);
+static void *Super_data(DOH *s);
+static int Super_cmp(DOH *, DOH *);
+static int Super_hash(DOH *s);
+static int Super_dump(DOH *s, DOH *out);
+static int Super_read(DOH *s, void *buffer, int length);
+static int Super_write(DOH *s, void *buffer, int length);
+static int Super_getc(DOH *s);
+static int Super_putc(DOH *s, int ch);
+static int Super_ungetc(DOH *s, int ch);
+static int Super_seek(DOH *s, long offset, int whence);
+static long Super_tell(DOH *s);
+static int Super_replace(DOH *str, DOH *token, DOH *rep, int flags);    
+static void Super_chop(DOH *str);
+
+/* internal functions */
+
+static void Super_add(Super *s, const char *newstr);
+static void Super_addchar(DOH *so, char c);
+static void Super_raw_insert(Super *s, int pos, char *data, int len);
+static void Super_tags_insert(Super *s, int pos, Super *new, int len);
+
+/* method tables */
+
+static DohSequenceMethods SuperSeqMethods = {
+  0,				/* doh_getitem */
+  0,				/* doh_setitem */
+  Super_delitem,		/* doh_delitem */
+  Super_insert,			/* doh_insitem */
+  0,				/* doh_first   */
+  0,				/* doh_next    */
+};
+
+static DohFileMethods SuperFileMethods = {
+  Super_read,
+  Super_write,
+  Super_putc,
+  Super_getc,
+  Super_ungetc,
+  Super_seek,
+  Super_tell,
+  0,
+};
+
+static DohSuperMethods SuperSuperMethods = {
+  Super_replace,
+};
+
+static DohObjInfo SuperType = {
+    "SuperString",		/* objname */
+    sizeof(Super),		/* objsize */
+    DelSuper,			/* doh_del */
+    CopySuper,			/* doh_copy */
+    Super_clear,		/* doh_clear */
+    0,				/* doh_scope */
+    Super_str,			/* doh_str */
+    Super_data,			/* doh_data */
+    Super_dump,			/* doh_dump */
+    0,				/* doh_load */
+    Super_len,			/* doh_len */
+    Super_hash,			/* doh_hash    */
+    Super_cmp,			/* doh_cmp */
+    0,				/* doh_mapping */
+    &SuperSeqMethods,		/* doh_sequence */
+    &SuperFileMethods,		/* doh_file */
+    &SuperStringMethods,	/* doh_string */ 
+    0,				/* doh_callable */ 
+};
+
+#define INIT_MAXSIZE  16
+#define INIT_MAXTAGS  2
+
+/* ---- Public Functions ---- */
+
+/* -------------------------------------------------------------------------
+ * NewSuperString(const char *c) - Create a new SuperString
+ * ------------------------------------------------------------------------- */
+DOH *
+NewSuper(char *s, DOH *filename, int firstline)
+{
+    int l = 0, max;
+    Super *str;
+
+    str = (Super *) DohObjMalloc(sizeof(Super));
+    str->objinfo = &SuperType;
+    str->hashkey = -1;
+    str->sp = 0;
+    str->lsp = 0;
+    str->pbi = 0;
+
+    max = INIT_MAXSIZE;
+    if (s)
+      {
+	l = (int) strlen(s);
+	if ((l+1) > max) max = l+1;
+      }
+    str->maxsize = max;
+
+    str->str = (char *) DohMalloc(max);
+    assert(str);
+    if (s)
+      copy_string(str->str,s);
+    else
+      str->str[0] = 0;
+
+    str->maxtags = INIT_MAXTAGS;
+    str->numtags = 1;
+
+    str->tags = (SSTag *) DohMalloc(max * sizeof(SSTag));
+    assert(str->tags);
+    str->tags[0].position = 0;
+    if (!String_check(filename) && !SuperString_check(filename))
+      filename = NewString(filename);
+    str->tags[0].filename = filename;
+
+    str->len = l;
+    return (DOH *) str;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_check(DOH *s) - Check if s is a Super
+ * ----------------------------------------------------------------------------- */
+int
+SuperString_check(DOH *s) 
+{
+  return (s && DohCheck(s) && ((Super *) c)->objinfo == &SuperType);
+}
+
+/* ---- "Member" Functions ---- */
+
+/* -------------------------------------------------------------------------
+ * CopySuper(DOH *s) - Copy a Super
+ * ------------------------------------------------------------------------- */
+static DOH *
+CopySuper(DOH *so)
+{
+  Super *s;
+  int max;
+  Super *str;
+  s = (Super *) so;
+  str = (Super *) DohObjMalloc(sizeof(Super));
+  str->objinfo = &SuperType;
+  str->hashkey = -1;
+  str->sp = 0;
+  str->lsp = 0;
+  str->pbi = 0;
+
+  max = s->maxsize;
+  str->str = (char *) DohMalloc(max);
+  memmove(str->str, s->str, s->len);
+  str->maxsize = max;
+  str->len = s->len;
+  str->str[str->len] = 0;
+
+  max = s->maxtags;
+  str->tags = (SSTag *) DohMalloc(max * sizeof(SSTag));
+  memmove(str->tags, s->tags, s->numtags * sizeof(SSTag));
+  str->numtags = s->numtags;
+  str->maxtags = s->maxtags;
+
+  return (DOH *) str;
+}
+  
+/* -------------------------------------------------------------------------
+ * DelSuper(DOH *s) - Delete a Super
+ * ------------------------------------------------------------------------- */
+static void
+DelSuper(DOH *so) 
+{
+  Super *s;
+  s = (Super *) so;
+  assert(s->refcount <= 0);
+
+  if (s->str) 
+    DohFree(s->str);
+  s->str = 0;
+
+  if (s->tags)
+    DohFree(s->tags);
+  s->tags = 0;
+
+  DohObjFree(s);
+}
+
+/* -------------------------------------------------------------------------
+ * void *Super_data(DOH *so) - Return as a 'void *'
+ * ------------------------------------------------------------------------- */
+static void *
+Super_data(DOH *so) 
+{
+  Super *s = (Super *) so;
+  s->str[s->len] = 0;
+  return (void *) s->str;
+}
+
+/* -------------------------------------------------------------------------
+ * int  Super_dump(DOH *so, DOH *out) 
+ *
+ * Serialize a Super onto out
+ * ------------------------------------------------------------------------- */
+
+static int
+Super_dump(DOH *so, DOH *out) 
+{
+  int nsent;
+  int ret;
+  Super *s;
+  
+  s = (Super *) so;
+  nsent = 0;
+  while (nsent < s->len) 
+    {
+      ret = Write(out,s->str+nsent,(s->len-nsent));
+      if (ret < 0) return ret;
+      nsent += ret;
+    }
+  return nsent;
+}
+
+/* -------------------------------------------------------------------------
+ * int Super_len(DOH *s) - Length of a Super
+ * ------------------------------------------------------------------------- */
+
+static int 
+Super_len(DOH *so) 
+{
+  Super *s = (Super *)so;
+  return s->len;
+}
+
+/* -------------------------------------------------------------------------
+ * int Super_cmp(DOH *s1, DOH *s2) - Compare two Supers
+ * ------------------------------------------------------------------------- */
+
+static int
+Super_cmp(DOH *so1, DOH *so2)
+{
+  /* we ignore all line number information */
+  Super *s1, *s2;
+  char *c1, *c2;
+  int  maxlen,i;
+  s1 = (Super *) so1;
+  s2 = (Super *) so2;
+  maxlen = s1->len;
+  if (s2->len < maxlen)
+    maxlen = s2->len;
+  c1 = s1->str;
+  c2 = s2->str;
+  for (i = 0; i < maxlen; i++,c1++,c2++) 
+    if (*c1 != *c2) break;
+  if (i < maxlen) 
+    {
+      if (*c1 < *c2) return -1;
+      else return 1;
+    }
+  if (s1->len == s2->len) return 0;
+  if (s1->len > s2->len) return 1;
+  return -1;
+}
+
+/* -------------------------------------------------------------------------
+ * int Super_hash(DOH *s) - Compute Super hash value
+ * ------------------------------------------------------------------------- */
+
+static int
+Super_hash(DOH *so)
+{
+  /* again, we ignore the line number information */
+  Super *s = (Super *) so;
+  char *c;
+  int   i, h = 0, len;
+  if (s->hashkey >= 0) return s->hashkey;
+  c = s->str;
+  len = s->len > 50 ? 50 : s->len;
+  for (i = 0; i < len; i++) 
+    {
+      h = (((h << 5) + *(c++))); 
+    }
+  h = h & 0x7fffffff;
+  s->hashkey = h;
+  return h;
+}  
+
+/* -------------------------------------------------------------------------
+ * void Super_clear(DOH *s) - Clear a Super
+ * ------------------------------------------------------------------------- */
+
+void
+Super_clear(DOH *so)
+{
+  Super *s;
+  s = (Super *) so;
+  s->hashkey = -1;
+  s->len = 0;
+  *(s->str) = 0;
+  s->sp = 0;
+  s->lsp = 0;
+  s->line = 1;
+  s->pbi = 0;
+  s->numtags = 0;
+}
+  
+/* -------------------------------------------------------------------------
+ * void Super_insert(DOH *so, int pos, SO *str) - Insert a Super
+ * ------------------------------------------------------------------------- */
+int
+Super_insert(DOH *so, int pos, DOH *str)
+{
+    Super *s, *s1;
+    char   *c;
+    int     len;
+    s = (Super *) so;
+    /*    assert(s->refcount <= 1); */ /* quasi-immutability?!? */
+    s1 = (Super *) str;
+    len = s1->len;
+    c = s1->str;
+    Super_raw_insert(s,pos,c,len);
+    Super_tags_insert(s,pos,s1,len);
+    return 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_delitem(DOH *so, int pos)
+ * 
+ * Delete an individual item
+ * ----------------------------------------------------------------------------- */
+
+int Super_delitem(DOH *so, int pos)
+{
+  Super *s = (Super *) so;
+  s->hashkey = -1;
+  if (pos == DOH_END) pos = s->len-1;
+  if (pos == DOH_BEGIN) pos = 0;
+  if (s->len == 0) return 0;
+
+  if (s->sp > pos) {
+    s->sp--;
+#ifdef DOH_Super_UPDATE_LINES
+    if (s->str[pos] == '\n') s->line--;
+#endif
+  }
+  memmove(s->str+pos, s->str+pos+1, ((s->len-1) - pos));
+  s->len--;
+  s->str[s->len] = 0;
+  return 0;
+}
+  
+/* -----------------------------------------------------------------------------
+ * DOH *Super_str(DOH *so) - Returns a Super (used by printing commands)
+ * ----------------------------------------------------------------------------- */
+
+DOH *
+Super_str(DOH *so) {
+    DOH *nstr;
+    Super *s = (Super *) so;
+    nstr = CopySuper(s);
+    return nstr;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_read(DOH *so, void *buffer, int len)
+ * 
+ * Read data from the Super
+ * ----------------------------------------------------------------------------- */
+int
+Super_read(DOH *so, void *buffer, int len) {
+  int    reallen, retlen;
+  char   *cb;
+  Super *s = (Super *) so;
+  if (((s->sp-s->pbi) + len) > s->len) reallen = (s->len - (s->sp-s->pbi));
+  else reallen = len;
+
+  cb = (char *) buffer;
+  retlen = reallen;
+
+  /* Read the push-back buffer contents first */
+  while (reallen > 0) {
+    if (s->pbi <= 0) break;
+    *(cb++) = (char) s->pb[--s->pbi];
+    reallen--;
+  }
+  if (reallen > 0) {
+    memmove(cb, s->str+s->sp, reallen);
+    s->sp += reallen;
+  }
+  return retlen;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_write(DOH *so, void *buffer, int len)
+ * 
+ * Write data to the Super
+ * ----------------------------------------------------------------------------- */
+int
+Super_write(DOH *so, void *buffer, int len) {
+  int    newlen;
+  Super *s = (Super *) so;
+  s->hashkey = -1;
+  newlen = s->sp + len+1;
+  if (newlen > s->maxsize) {
+    s->str = (char *) DohRealloc(s->str,newlen);
+    assert(s->str);
+    s->maxsize = newlen;
+    s->len = s->sp + len;
+  }
+  if ((s->sp+len) > s->len) s->len = s->sp + len;
+  memmove(s->str+s->sp,buffer,len);
+  s->sp += len;
+  s->pbi = 0;
+  return len;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_seek(DOH *so, long offset, int whence)
+ * 
+ * Seek to a new position
+ * ----------------------------------------------------------------------------- */
+int
+Super_seek(DOH *so, long offset, int whence) {
+  int    pos, nsp, inc;
+  Super *s = (Super *) so;
+  if (whence == SEEK_SET) pos = 0;
+  else if (whence == SEEK_CUR) pos = s->sp;
+  else if (whence == SEEK_END) {
+    pos = s->len;
+    offset = -offset;
+  }
+  else pos = s->sp;
+
+  nsp = pos + offset;
+  if (nsp < 0) nsp = 0;
+  if (nsp > s->len) nsp = s->len;
+  if (nsp > s->sp) inc = 1;
+  else inc = -1;
+#ifdef DOH_Super_UPDATE_LINES
+  while (s->sp != nsp) { 
+    if (s->str[s->sp-1] == '\n') s->line += inc;
+    s->sp += inc;
+  }
+#endif
+  s->sp = nsp;
+  s->pbi = 0;
+  return 0;
+}
+
+/* -----------------------------------------------------------------------------
+ * long Super_tell(DOH *so)
+ * 
+ * Return current position
+ * ----------------------------------------------------------------------------- */
+long
+Super_tell(DOH *so) {
+  Super *s = (Super *) so;
+  return (long) (s->sp - s->pbi);
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_putc(DOH *so, int ch)
+ *
+ * Put a character into the Super.
+ * ----------------------------------------------------------------------------- */
+
+int
+Super_putc(DOH *so, int ch) {
+  Super *s = (Super *) so;
+  s->hashkey = -1;
+  if (s->sp >= s->len) {
+    Super_addchar(s,(char) ch);
+  } else {
+    s->str[s->sp] = (char) ch;
+    s->sp++;
+#ifdef DOH_Super_UPDATE_LINES
+  if (ch == '\n') s->line++;
+#endif
+  }
+  s->pbi = 0;
+  return ch;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_getc(DOH *so)
+ *
+ * Get a character from the Super.  Updates the line number.
+ * ----------------------------------------------------------------------------- */
+
+int Super_getc(DOH *so) {
+  int c;
+  Super *s = (Super *) so;
+
+  if (s->pbi) {
+    c = (int) s->pb[--s->pbi];
+  } else if (s->sp >= s->len) c = EOF;
+  else c = (int) s->str[s->sp++];
+#ifdef DOH_Super_UPDATE_LINES
+  if (c == '\n') s->line++;
+#endif
+  return c;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_ungetc(DOH *so, int ch)
+ *
+ * Put a character back on to the input stream.  Updates the line count.
+ * ----------------------------------------------------------------------------- */
+int Super_ungetc(DOH *so, int ch) {
+  Super *s = (Super *) so;
+  if (ch == EOF) return ch;
+  if ((s->sp - s->pbi) <= 0) return EOF;
+  if (s->pbi == 4) {
+    s->pb[0] = s->pb[1];
+    s->pb[1] = s->pb[2];
+    s->pb[2] = s->pb[3];
+    s->pb[3] = (char) ch;
+  } else {
+    s->pb[s->pbi++] = (char) ch;
+  }
+#ifdef DOH_Super_UPDATE_LINES
+  if (ch == '\n') s->line--;
+#endif
+  return ch;
+}
+
+/* -----------------------------------------------------------------------------
+ * int replace_internal(Super *str, char *token, char *rep, int flags, char *start, int count)
+ *
+ * Replaces token with rep.  flags is as follows:
+ *
+ *         REPLACE_ANY           -   Replace all occurrences
+ *         REPLACE_NOQUOTE       -   Don't replace in quotes
+ *         REPLACE_ID            -   Only replace valid identifiers
+ *         REPLACE_FIRST         -   Only replace first occurrence
+ * 
+ * start is a starting position. count is a count.
+ * ----------------------------------------------------------------------------- */
+
+static
+int replace_internal(Super *str, char *token, char *rep, int flags, char *start, int count)
+{
+    char *s, *c, *t;
+    int  tokenlen;
+    int  state;
+    int  repcount = 0;
+
+    /* Copy the current Super representation */
+
+    s = str->str;
+    str->hashkey = -1;
+
+    tokenlen = strlen(token);
+
+    /* If a starting position was given, dump those characters first */
+  
+    if (start) {
+	c = start;
+    } else {
+	c = s;
+    }
+
+    /* Now walk down the old Super and search for tokens */
+    t = strstr(c,token);
+    if (t) {
+	str->len = 0;
+	str->str = (char *) DohMalloc(str->maxsize);
+	if (start) {
+	    char temp = *start;
+	    *start = 0;
+	    Super_add(str,s);
+	    *start = temp;
+	}
+
+	/* Depending on flags.  We compare in different ways */
+	state = 0;
+	t = c;
+	while ((*c) && (count)) {
+	    switch(state) {
+	    case 0:
+		if (*c == *token) {
+		    if (!(flags & DOH_REPLACE_ID)) {
+			if (strncmp(c,token,tokenlen) == 0) {
+			    char temp = *c;
+			    *c = 0;
+			    Super_add(str,t);
+			    *c = temp;
+			    Super_add(str,rep);
+			    c += (tokenlen-1);
+			    t = c+1;
+			    count--;
+			    repcount++;
+			}
+		    } else if (isalpha(*c) || (*c == '_') || (*c == '$')) {
+			char temp = *c;
+			*c = 0;
+			Super_add(str,t);
+			*c = temp;
+			t = c;
+			state = 10;
+		    } 
+		} else if (flags & DOH_REPLACE_NOQUOTE) {
+		    if (*c == '\"') state = 20;
+		    else if (*c == '\'') state = 30;
+		}
+		break;
+	    case 10:  /* The start of an identifier */
+		if (isalnum(*c) || (*c == '_') || (*c == '$')) state = 10;
+		else {
+		    char temp = *c;
+		    *c = 0;
+		    if (strcmp(token,t) == 0) {
+			Super_add(str,rep);
+			count--;
+			repcount++;
+		    } else {
+			Super_add(str,t);
+		    }
+		    *c = temp;
+		    t = c;
+		    state = 0;
+		}
+		break;
+	    case 20: /* A Super */
+		if (*c == '\"') state = 0;
+		else if (*c == '\\') c++;
+		break;
+	    case 30: /* A Single quoted Super */
+		if (*c == '\'') state = 0;
+		else if (*c == '\\') c++;
+		break;
+	    }
+	    c++;
+	}
+	if ((count) && (state == 10)) {
+	    if (strcmp(token,t) == 0) {
+		Super_add(str,rep);
+	    } else {
+		Super_add(str,t);
+	    }
+	} else {
+	    Super_add(str,t);
+	}
+	DohFree(s);
+    }
+    return repcount;
+}
+
+/* -----------------------------------------------------------------------------
+ * int Super_replace(DOH *str, DOH *token, DOH *rep, int flags)
+ * ----------------------------------------------------------------------------- */
+
+int 
+Super_replace(DOH *stro, DOH *token, DOH *rep, int flags)
+{
+    int count = -1;
+    Super *str;
+    if (!Super_check(stro)) return 0;
+    str = (Super *) stro;
+    assert(str->refcount);
+    /* assert(!str->refcount); */
+    if (flags & DOH_REPLACE_FIRST) count = 1;
+    return replace_internal(str,Char(token),Char(rep),flags,str->str,count);
+}
+
+/* -----------------------------------------------------------------------------
+ * void Super_chop(DOH *str)
+ * ----------------------------------------------------------------------------- */
+
+void
+Super_chop(DOH *s) {
+  char *c;
+  Super *str = (Super *) s;
+  if (!Super_check(s)) return;
+  /* assert(!str->refcount); */
+  
+  /* Replace trailing whitespace */
+  c = str->str + str->len - 1;
+  while ((str->len >= 0) && (isspace(*c))) {
+    if (str->sp >= str->len) {
+      str->sp--;
+#ifdef DOH_Super_UPDATE_LINES
+      if (*c == '\n') str->line--;
+#endif
+    }
+    str->len--;
+    c--;
+  }
+  str->hashkey = -1;
+  str->pbi = 0;
+}
+
+/* ---- internal functions ---- */
+  
+/* -------------------------------------------------------------------------
+ * static Super_add(Super *s, const char *newstr) - Append to s
+ * ------------------------------------------------------------------------- */
+
+static void
+Super_add(Super *s, const char *newstr)
+{
+  int   newlen, newmaxsize, l, i;
+  if (!newstr) return;
+  s->hashkey = -1;
+  l = (int) strlen(newstr);
+  newlen = s->len+l + 1;
+  if (newlen >= s->maxsize-1) {
+    newmaxsize = 2*s->maxsize;
+    if (newlen >= newmaxsize -1) newmaxsize = newlen + 1;
+    s->str = (char *) DohRealloc(s->str,newmaxsize);
+    assert(s->str);
+    s->maxsize = newmaxsize;
+  }
+  strcpy(s->str+s->len,newstr);
+  if (s->sp >= s->len) {
+#ifdef DOH_Super_UPDATE_LINES
+    for (i = s->sp; i < s->len+l; i++) {
+      if (s->str[i] == '\n') s->line++;
+    }
+#endif
+    s->sp = s->len+l;
+  }
+  s->len += l;
+}  
+
+/* -------------------------------------------------------------------------
+ * static Super_addchar(DOH *so, char c) - Add a single character to s
+ * ------------------------------------------------------------------------- */
+
+static void
+Super_addchar(DOH *so, char c) {
+  Super *s = (Super *) so;
+  s->hashkey = -1;
+  if ((s->len+1) > (s->maxsize-1)) {
+    s->str = (char *) DohRealloc(s->str,2*s->maxsize);
+    assert(s->str);
+    s->maxsize *= 2;
+  }
+  s->str[s->len] = c;
+  if (s->sp >= s->len) {
+    s->sp = s->len+1;
+    s->str[s->len+1] = 0;
+#ifdef DOH_Super_UPDATE_LINES
+    if (c == '\n') s->line++;
+#endif
+  }
+  s->len++;
+}
+
+/* -------------------------------------------------------------------------
+ * static Super_raw_insert(Super *s, int pos, char *data, int len)
+ * ------------------------------------------------------------------------- */
+
+static void
+Super_raw_insert(Super *s, int pos, char *data, int len)
+{
+    char *nstr;
+    nstr = s->str;
+    s->hashkey = -1;
+    if (pos == DOH_END) {
+	Super_add(s, data);
+	return;
+    }
+    if (pos < 0) pos = 0;
+    else if (pos > s->len) pos = s->len;
+
+    /* See if there is room to insert the new data */
+
+    while (s->maxsize <= s->len+len) {
+	s->str = (char *) DohRealloc(s->str,2*s->maxsize);
+	assert(s->str);
+	s->maxsize *= 2;
+    }
+    memmove(s->str+pos+len, s->str+pos, (s->len - pos));
+    memcpy(s->str+pos,data,len);
+    if (s->sp >= s->len) {
+      int i;
+      s->sp = s->len;
+#ifdef DOH_Super_UPDATE_LINES
+      for (i = 0; i < len; i++) {
+	if (data[i] == '\n') s->line++;
+      }
+#endif
+      s->sp+=len;
+    }
+    s->len += len; 
+    s->str[s->len] = 0;
+}  
+
+/* -------------------------------------------------------------------------
+ * static Super_tags_insert(Super *s, int pos, char *data, int len)
+ * ------------------------------------------------------------------------- */
+
+static void 
+Super_tags_insert(Super *s, int pos, Super *new, int len)
+{
+}
+#endif
diff --git a/SWIG/Source/Swig/swigcore.h b/SWIG/Source/Swig/swigcore.h
index dd136ea3e..8461b055b 100644
--- a/SWIG/Source/Swig/swigcore.h
+++ b/SWIG/Source/Swig/swigcore.h
@@ -40,6 +40,7 @@ extern DOH  *SWIG_include(DOH *name);
 #define  FILE_DELIMETER   "/"
 
 /* --- Command line parsing --- */
+
 extern void  SWIG_init_args(int argc, char **argv);
 extern void  SWIG_mark_arg(int n);
 extern void  SWIG_check_options();
@@ -113,6 +114,7 @@ extern int      Scanner_get_line(Scanner *);
 #define   TOKEN_ILLEGAL      98
 #define   TOKEN_LAST         99 
 
+/* --- Misc --- */
 
 extern char *copy_string(const char *c);