diff --git a/Source/CParse/parser.y b/Source/CParse/parser.y
index 5050a2516..9f0f7c1c6 100644
--- a/Source/CParse/parser.y
+++ b/Source/CParse/parser.y
@@ -23,6 +23,7 @@
 char cvsroot_parser_y[] = "$Header$";
 
 #include "swig.h"
+#include "swigkeys.h"
 #include "cparse.h"
 #include "preprocessor.h"
 #include <ctype.h>
@@ -255,7 +256,7 @@ static String *make_unnamed() {
 
 /* Return if the node is a friend declaration */
 static int is_friend(Node *n) {
-  return Cmp(Getattr(n,"storage"),"friend") == 0;
+  return Cmp(Getattr(n,k_storage),"friend") == 0;
 }
 
 static int is_operator(String *name) {
@@ -279,7 +280,7 @@ static void add_symbols(Node *n) {
     Symtab *old_scope = 0;
     int isfriend = inclass && is_friend(n);
     if (inclass) {
-      String *name = Getattr(n, "name");
+      String *name = Getattr(n, k_name);
       if (isfriend) {
 	/* for friends, we need to add the scopename if needed */
 	String *prefix = name ? Swig_scopename_prefix(name) : 0;
@@ -289,15 +290,15 @@ static void add_symbols(Node *n) {
 	if (!prefix) {
 	  if (name && Namespaceprefix) {
 	    String *nname = NewStringf("%s::%s", Namespaceprefix, name);
-	    Setattr(n,"name",nname);
+	    Setattr(n,k_name,nname);
 	    Delete(nname);
 	  }
 	} else {
 	  Symtab *st = Swig_symbol_getscope(prefix);
-	  String *ns = st ? Getattr(st,"name") : prefix;
+	  String *ns = st ? Getattr(st,k_name) : prefix;
 	  String *base  = Swig_scopename_last(name);
 	  String *nname = NewStringf("%s::%s", ns, base);
-	  Setattr(n,"name",nname);
+	  Setattr(n,k_name,nname);
 	  Delete(nname);
 	  Delete(base);
 	  Delete(prefix);
@@ -315,7 +316,7 @@ static void add_symbols(Node *n) {
 	if (prefix) {
 	  if (Classprefix && (StringEqual(prefix,Classprefix))) {
 	    String *base = Swig_scopename_last(name);
-	    Setattr(n,"name",base);
+	    Setattr(n,k_name,base);
 	    Delete(base);
 	  }
 	  Delete(prefix);
@@ -325,13 +326,13 @@ static void add_symbols(Node *n) {
     if (!isfriend && inclass && (cplus_mode != CPLUS_PUBLIC)) {
       int only_csymbol = 1;
       if (cplus_mode == CPLUS_PROTECTED) {
-	Setattr(n,"access", "protected");
+	Setattr(n,k_access, "protected");
 	only_csymbol = !Swig_need_protected(n);
       } else {
 	/* private are needed only when they are pure virtuals */
-	Setattr(n,"access", "private");
-	if ((Cmp(Getattr(n,"storage"),"virtual") == 0) 
-	    && (Cmp(Getattr(n,"value"),"0") == 0)) {
+	Setattr(n,k_access, "private");
+	if ((Cmp(Getattr(n,k_storage),"virtual") == 0) 
+	    && (Cmp(Getattr(n,k_value),"0") == 0)) {
 	  only_csymbol = !Swig_need_protected(n);
 	}    
       }
@@ -343,36 +344,36 @@ static void add_symbols(Node *n) {
 	continue;
       }
     }
-    if (Getattr(n,"sym:name")) {
+    if (Getattr(n,k_symname)) {
       n = nextSibling(n);
       continue;
     }
-    decl = Getattr(n,"decl");
+    decl = Getattr(n,k_decl);
     if (!SwigType_isfunction(decl)) {
       String *makename = Getattr(n,"parser:makename");
       if (makename) {
 	symname = make_name(n, makename,0);
         Delattr(n,"parser:makename"); /* temporary information, don't leave it hanging around */
       } else {
-        makename = Getattr(n,"name");
+        makename = Getattr(n,k_name);
 	symname = make_name(n, makename,0);
       }
       
       if (!symname) {
-	symname = Copy(Getattr(n,"unnamed"));
+	symname = Copy(Getattr(n,k_unnamed));
       }
       if (symname) {
 	wrn = Swig_name_warning(n, Namespaceprefix, symname,0);
-	Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr(n,"name"), 0, n);
+	Swig_features_get(Swig_cparse_features(), Namespaceprefix, Getattr(n,k_name), 0, n);
       }
     } else {
       SwigType *fdecl = Copy(decl);
       SwigType *fun = SwigType_pop_function(fdecl);
 
-      symname = make_name(n, Getattr(n,"name"),fun);
+      symname = make_name(n, Getattr(n,k_name),fun);
       wrn = Swig_name_warning(n, Namespaceprefix,symname,fun);
       
-      Swig_features_get(Swig_cparse_features(),Namespaceprefix,Getattr(n,"name"),fun,n);
+      Swig_features_get(Swig_cparse_features(),Namespaceprefix,Getattr(n,k_name),fun,n);
       Delete(fdecl);
       Delete(fun);
       
@@ -405,8 +406,8 @@ static void add_symbols(Node *n) {
 
       if (c != n) {
         /* symbol conflict attempting to add in the new symbol */
-        if (Getattr(n,"sym:weak")) {
-          Setattr(n,"sym:name",symname);
+        if (Getattr(n,k_symweak)) {
+          Setattr(n,k_symname,symname);
         } else {
           String *e = NewStringEmpty();
           String *en = NewStringEmpty();
@@ -419,12 +420,12 @@ static void add_symbols(Node *n) {
             Printf(en,"Redundant redeclaration of '%s'",symname);
             Printf(ec,"previous declaration of '%s'",symname);
           }
-          if (Cmp(symname,Getattr(n,"name"))) {
-            Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,"name")));
+          if (Cmp(symname,Getattr(n,k_name))) {
+            Printf(en," (Renamed from '%s')", SwigType_namestr(Getattr(n,k_name)));
           }
           Printf(en,",");
-          if (Cmp(symname,Getattr(c,"name"))) {
-            Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,"name")));
+          if (Cmp(symname,Getattr(c,k_name))) {
+            Printf(ec," (Renamed from '%s')", SwigType_namestr(Getattr(c,k_name)));
           }
           Printf(ec,".");
 	  SWIG_WARN_NODE_BEGIN(n);
@@ -438,7 +439,7 @@ static void add_symbols(Node *n) {
 	  SWIG_WARN_NODE_END(n);
           Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(n),Getline(n),en,
                  Getfile(c),Getline(c),ec);
-          Setattr(n,"error",e);
+          Setattr(n,k_error,e);
 	  Delete(e);
           Delete(en);
           Delete(ec);
@@ -470,7 +471,7 @@ static void add_symbols_copy(Node *n) {
     char *cnodeType = Char(nodeType(n));
 
     if (strcmp(cnodeType,"access") == 0) {
-      String *kind = Getattr(n,"kind");
+      String *kind = Getattr(n,k_kind);
       if (Strcmp(kind,"public") == 0) {
 	cplus_mode = CPLUS_PUBLIC;
       } else if (Strcmp(kind,"private") == 0) {
@@ -482,27 +483,27 @@ static void add_symbols_copy(Node *n) {
       continue;
     }
 
-    add_oldname = Getattr(n,"sym:name");
+    add_oldname = Getattr(n,k_symname);
     if ((add_oldname) || (Getattr(n,"sym:needs_symtab"))) {
       if (add_oldname) {
 	DohIncref(add_oldname);
 	/* If already renamed, we used that name */
-	if (Strcmp(add_oldname, Getattr(n,"name")) != 0) {
+	if (Strcmp(add_oldname, Getattr(n,k_name)) != 0) {
 	  Delete(yyrename);
 	  yyrename = Copy(add_oldname);
 	}
       }
       Delattr(n,"sym:needs_symtab");
-      Delattr(n,"sym:name");
+      Delattr(n,k_symname);
 
       add_only_one = 1;
       add_symbols(n);
 
-      if (Getattr(n,"partialargs")) {
-	Swig_symbol_cadd(Getattr(n,"partialargs"),n);
+      if (Getattr(n,k_partialargs)) {
+	Swig_symbol_cadd(Getattr(n,k_partialargs),n);
       }
       add_only_one = 0;
-      name = Getattr(n,"name");
+      name = Getattr(n,k_name);
       if (Getattr(n,"requires_symtab")) {
 	Swig_symbol_newscope();
 	Swig_symbol_setscopename(name);
@@ -511,7 +512,7 @@ static void add_symbols_copy(Node *n) {
       }
       if (strcmp(cnodeType,"class") == 0) {
 	inclass = 1;
-	if (Strcmp(Getattr(n,"kind"),"class") == 0) {
+	if (Strcmp(Getattr(n,k_kind),"class") == 0) {
 	  cplus_mode = CPLUS_PRIVATE;
 	} else {
 	  cplus_mode = CPLUS_PUBLIC;
@@ -526,7 +527,7 @@ static void add_symbols_copy(Node *n) {
 	cplus_mode = emode;
       }
       if (Getattr(n,"requires_symtab")) {
-	Setattr(n,"symtab", Swig_symbol_popscope());
+	Setattr(n,k_symtab, Swig_symbol_popscope());
 	Delattr(n,"requires_symtab");
 	Delete(Namespaceprefix);
 	Namespaceprefix = Swig_symbol_qualifiedscopename(0);
@@ -565,23 +566,23 @@ static void merge_extensions(Node *cls, Node *am) {
   while (n) {
     String *symname;
     if (Strcmp(nodeType(n),"constructor") == 0) {
-      symname = Getattr(n,"sym:name");
+      symname = Getattr(n,k_symname);
       if (symname) {
-	if (Strcmp(symname,Getattr(n,"name")) == 0) {
+	if (Strcmp(symname,Getattr(n,k_name)) == 0) {
 	  /* If the name and the sym:name of a constructor are the same,
              then it hasn't been renamed.  However---the name of the class
              itself might have been renamed so we need to do a consistency
              check here */
-	  if (Getattr(cls,"sym:name")) {
-	    Setattr(n,"sym:name", Getattr(cls,"sym:name"));
+	  if (Getattr(cls,k_symname)) {
+	    Setattr(n,k_symname, Getattr(cls,k_symname));
 	  }
 	}
       } 
     }
 
-    symname = Getattr(n,"sym:name");
+    symname = Getattr(n,k_symname);
     DohIncref(symname);
-    if ((symname) && (!Getattr(n,"error"))) {
+    if ((symname) && (!Getattr(n,k_error))) {
       /* Remove node from its symbol table */
       Swig_symbol_remove(n);
       csym = Swig_symbol_add(symname,n);
@@ -598,7 +599,7 @@ static void merge_extensions(Node *cls, Node *am) {
 	SWIG_WARN_NODE_END(n);
 	Printf(e,"%s:%d:%s\n%s:%d:%s\n",Getfile(csym),Getline(csym),ec, 
 	       Getfile(n),Getline(n),en);
-	Setattr(csym,"error",e);
+	Setattr(csym,k_error,e);
 	Delete(e);
 	Delete(en);
 	Delete(ec);
@@ -658,24 +659,24 @@ static List *pure_abstract(Node *n) {
   List *abs = 0;
   while (n) {
     if (Cmp(nodeType(n),"cdecl") == 0) {
-      String *decl = Getattr(n,"decl");
+      String *decl = Getattr(n,k_decl);
       if (SwigType_isfunction(decl)) {
-	String *init = Getattr(n,"value");
+	String *init = Getattr(n,k_value);
 	if (Cmp(init,"0") == 0) {
 	  if (!abs) {
 	    abs = NewList();
 	  }
 	  Append(abs,n);
-	  Setattr(n,"abstract","1");
+	  Setattr(n,k_abstract,"1");
 	}
       }
     } else if (Cmp(nodeType(n),"destructor") == 0) {
-      if (Cmp(Getattr(n,"value"),"0") == 0) {
+      if (Cmp(Getattr(n,k_value),"0") == 0) {
 	if (!abs) {
 	  abs = NewList();
 	}
 	Append(abs,n);
-	Setattr(n,"abstract","1");
+	Setattr(n,k_abstract,"1");
       }
     }
     n = nextSibling(n);
@@ -724,10 +725,10 @@ static List *make_inherit_list(String *clsname, List *names) {
     if (s) {
       while (s && (Strcmp(nodeType(s),"class") != 0)) {
 	/* Not a class.  Could be a typedef though. */
-	String *storage = Getattr(s,"storage");
+	String *storage = Getattr(s,k_storage);
 	if (storage && (Strcmp(storage,"typedef") == 0)) {
-	  String *nn = Getattr(s,"type");
-	  s = Swig_symbol_clookup(nn,Getattr(s,"sym:symtab"));
+	  String *nn = Getattr(s,k_type);
+	  s = Swig_symbol_clookup(nn,Getattr(s,k_symsymtab));
 	} else {
 	  break;
 	}
@@ -736,10 +737,10 @@ static List *make_inherit_list(String *clsname, List *names) {
 	String *q = Swig_symbol_qualified(s);
 	Append(bases,s);
 	if (q) {
-	  base = NewStringf("%s::%s", q, Getattr(s,"name"));
+	  base = NewStringf("%s::%s", q, Getattr(s,k_name));
 	  Delete(q);
 	} else {
-	  base = NewString(Getattr(s,"name"));
+	  base = NewString(Getattr(s,k_name));
 	}
       } else {
 	base = NewString(n);
@@ -790,11 +791,11 @@ static String *resolve_node_scope(String *cname) {
     if (!prefix || (Len(prefix) == 0)) {
       /* Use the global scope, but we need to add a 'global' namespace.  */
       if (!gscope) gscope = get_global_scope();
-      /* note that this namespace is not the "unnamed" one,
-	 and we don't use Setattr(nscope,"name", ""),
+      /* note that this namespace is not the k_unnamed one,
+	 and we don't use Setattr(nscope,k_name, ""),
 	 because the unnamed namespace is private */
-      nscope = new_node("namespace");
-      Setattr(nscope,"symtab", gscope);;
+      nscope = new_node(k_namespace);
+      Setattr(nscope,k_symtab, gscope);;
       nscope_inner = nscope;
       return base;
     }
@@ -803,7 +804,7 @@ static String *resolve_node_scope(String *cname) {
     if (!ns) {
       Swig_error(cparse_file,cparse_line,"Undefined scope '%s'\n", prefix);
     } else {
-      Symtab *nstab = Getattr(ns,"symtab");
+      Symtab *nstab = Getattr(ns,k_symtab);
       if (!nstab) {
 	Swig_error(cparse_file,cparse_line,
 		   "'%s' is not defined as a valid scope.\n", prefix);
@@ -841,8 +842,8 @@ static String *resolve_node_scope(String *cname) {
 	  ns1 = Swig_symbol_clookup(sname,0);
 	  assert(ns1);
 	  if (Strcmp(nodeType(ns1),"namespace") == 0) {
-	    if (Getattr(ns1,"alias")) {
-	      ns1 = Getattr(ns1,"namespace");
+	    if (Getattr(ns1,k_alias)) {
+	      ns1 = Getattr(ns1,k_namespace);
 	    }
 	  } else {
 	    /* now this last part is a class */
@@ -857,7 +858,7 @@ static String *resolve_node_scope(String *cname) {
 	    /* we get the 'inner' class */
 	    nscope_inner = Swig_symbol_clookup(sname,0);
 	    /* set the scope to the inner class */
-	    Swig_symbol_setscope(Getattr(nscope_inner,"symtab"));
+	    Swig_symbol_setscope(Getattr(nscope_inner,k_symtab));
 	    /* save the last namespace prefix */
 	    Delete(Namespaceprefix);
 	    Namespaceprefix = Swig_symbol_qualifiedscopename(0);
@@ -866,14 +867,14 @@ static String *resolve_node_scope(String *cname) {
 	  }
 	  /* here we just populate the namespace tree as usual */
 	  ns2 = new_node("namespace");
-	  Setattr(ns2,"name",sname);
-	  Setattr(ns2,"symtab", Getattr(ns1,"symtab"));
+	  Setattr(ns2,k_name,sname);
+	  Setattr(ns2,k_symtab, Getattr(ns1,k_symtab));
 	  add_symbols(ns2);
-	  Swig_symbol_setscope(Getattr(ns1,"symtab"));
+	  Swig_symbol_setscope(Getattr(ns1,k_symtab));
 	  Delete(Namespaceprefix);
 	  Namespaceprefix = Swig_symbol_qualifiedscopename(0);
 	  if (nscope_inner) {
-	    if (Getattr(nscope_inner,"symtab") != Getattr(ns2,"symtab")) {
+	    if (Getattr(nscope_inner,k_symtab) != Getattr(ns2,k_symtab)) {
 	      appendChild(nscope_inner,ns2);
 	      Delete(ns2);
 	    }
@@ -949,13 +950,13 @@ static Node *dump_nested(const char *parent) {
 
     /* Add the appropriate declaration to the C++ processor */
     retx = new_node("cdecl");
-    Setattr(retx,"name",n->name);
+    Setattr(retx,k_name,n->name);
     nt = Copy(n->type);
-    Setattr(retx,"type",nt);
+    Setattr(retx,k_type,nt);
     Delete(nt);
     Setattr(retx,"nested",parent);
     if (n->unnamed) {
-      Setattr(retx,"unnamed","1");
+      Setattr(retx,k_unnamed,"1");
     }
     
     add_symbols(retx);
@@ -968,8 +969,8 @@ static Node *dump_nested(const char *parent) {
     /* Insert a forward class declaration */
     /* Disabled: [ 597599 ] union in class: incorrect scope 
        retx = new_node("classforward");
-       Setattr(retx,"kind",n->kind);
-       Setattr(retx,"name",Copy(n->type));
+       Setattr(retx,k_kind,n->kind);
+       Setattr(retx,k_name,Copy(n->type));
        Setattr(retx,"sym:name", make_name(n->type,0));
        set_nextSibling(retx,ret);
        ret = retx; 
@@ -1021,7 +1022,7 @@ static Node *dump_nested(const char *parent) {
     {
       Node *head = new_node("insert");
       String *code = NewStringf("\n%s\n",n->code);
-      Setattr(head,"code", code);
+      Setattr(head,k_code, code);
       Delete(code);
       set_nextSibling(head,ret);
       Delete(ret);      
@@ -1067,7 +1068,7 @@ static void single_new_feature(const char *featurename, String *val, Hash *featu
     name = fixname;
   }
 
-  if (declaratorparms) Setmeta(val,"parms",declaratorparms);
+  if (declaratorparms) Setmeta(val,k_parms,declaratorparms);
   if (!Len(t)) t = 0;
   if (t) {
     if (qualifier) SwigType_push(t,qualifier);
@@ -1130,7 +1131,7 @@ static void new_feature(const char *featurename, String *val, Hash *featureattri
 /* check if a function declaration is a plain C object */
 static int is_cfunction(Node *n) {
   if (!cparse_cplusplus || cparse_externc) return 1;
-  if (Cmp(Getattr(n,"storage"),"externc") == 0) {
+  if (Cmp(Getattr(n,k_storage),"externc") == 0) {
     return 1;
   }
   return 0;
@@ -1147,10 +1148,10 @@ static void default_arguments(Node *n) {
     if (varargs) {
       /* Handles the %varargs directive by looking for "feature:varargs" and 
        * substituting ... with an alternative set of arguments.  */
-      Parm     *p = Getattr(function,"parms");
+      Parm     *p = Getattr(function,k_parms);
       Parm     *pp = 0;
       while (p) {
-	SwigType *t = Getattr(p,"type");
+	SwigType *t = Getattr(p,k_type);
 	if (Strcmp(t,"v(...)") == 0) {
 	  if (pp) {
 	    ParmList *cv = Copy(varargs);
@@ -1158,7 +1159,7 @@ static void default_arguments(Node *n) {
 	    Delete(cv);
 	  } else {
 	    ParmList *cv =  Copy(varargs);
-	    Setattr(function,"parms", cv);
+	    Setattr(function,k_parms, cv);
 	    Delete(cv);
 	  }
 	  break;
@@ -1174,15 +1175,15 @@ static void default_arguments(Node *n) {
 	|| is_cfunction(function) 
 	|| GetFlag(function,"feature:compactdefaultargs") 
 	|| GetFlag(function,"feature:kwargs")) {
-      ParmList *p = Getattr(function,"parms");
+      ParmList *p = Getattr(function,k_parms);
       if (p) 
-        Setattr(p,"compactdefargs", "1"); /* mark parameters for special handling */
+        Setattr(p,k_compactdefargs, "1"); /* mark parameters for special handling */
       function = 0; /* don't add in extra methods */
     }
   }
 
   while (function) {
-    ParmList *parms = Getattr(function,"parms");
+    ParmList *parms = Getattr(function,k_parms);
     if (ParmList_has_defaultargs(parms)) {
 
       /* Create a parameter list for the new function by copying all
@@ -1194,25 +1195,25 @@ static void default_arguments(Node *n) {
 	SwigType *ntype = Copy(nodeType(function));
 	char *cntype = Char(ntype);
         Node *new_function = new_node(ntype);
-        SwigType *decl = Copy(Getattr(function,"decl"));
+        SwigType *decl = Copy(Getattr(function,k_decl));
         int constqualifier = SwigType_isconst(decl);
-	String *ccode = Copy(Getattr(function,"code"));
-	String *cstorage = Copy(Getattr(function,"storage"));
-	SwigType *ctype = Copy(Getattr(function,"type"));
-	String *cthrow = Copy(Getattr(function,"throw"));
+	String *ccode = Copy(Getattr(function,k_code));
+	String *cstorage = Copy(Getattr(function,k_storage));
+	SwigType *ctype = Copy(Getattr(function,k_type));
+	String *cthrow = Copy(Getattr(function,k_throw));
 
         Delete(SwigType_pop_function(decl)); /* remove the old parameter list from decl */
         SwigType_add_function(decl,newparms);
         if (constqualifier)
           SwigType_add_qualifier(decl,"const");
 
-        Setattr(new_function,"name", Getattr(function,"name"));
-        Setattr(new_function,"code", ccode);
-        Setattr(new_function,"decl", decl);
-        Setattr(new_function,"parms", newparms);
-        Setattr(new_function,"storage", cstorage);
-        Setattr(new_function,"type", ctype);
-        Setattr(new_function,"throw", cthrow);
+        Setattr(new_function,k_name, Getattr(function,k_name));
+        Setattr(new_function,k_code, ccode);
+        Setattr(new_function,k_decl, decl);
+        Setattr(new_function,k_parms, newparms);
+        Setattr(new_function,k_storage, cstorage);
+        Setattr(new_function,k_type, ctype);
+        Setattr(new_function,k_throw, cthrow);
 
 	Delete(ccode);
 	Delete(cstorage);
@@ -1221,30 +1222,30 @@ static void default_arguments(Node *n) {
 	Delete(decl);
 
         {
-          Node *throws = Getattr(function,"throws");
+          Node *throws = Getattr(function,k_throws);
 	  ParmList *pl = CopyParmList(throws);
-          if (throws) Setattr(new_function,"throws",pl);
+          if (throws) Setattr(new_function,k_throws,pl);
 	  Delete(pl);
         }
 
         /* copy specific attributes for global (or in a namespace) template functions - these are not templated class methods */
         if (strcmp(cntype,"template") == 0) {
-          Node *templatetype = Getattr(function,"templatetype");
-          Node *symtypename = Getattr(function,"sym:typename");
-          Parm *templateparms = Getattr(function,"templateparms");
+          Node *templatetype = Getattr(function,k_templatetype);
+          Node *symtypename = Getattr(function,k_symtypename);
+          Parm *templateparms = Getattr(function,k_templateparms);
           if (templatetype) {
 	    Node *tmp = Copy(templatetype);
-	    Setattr(new_function,"templatetype",tmp);
+	    Setattr(new_function,k_templatetype,tmp);
 	    Delete(tmp);
 	  }
           if (symtypename) {
 	    Node *tmp = Copy(symtypename);
-	    Setattr(new_function,"sym:typename",tmp);
+	    Setattr(new_function,k_symtypename,tmp);
 	    Delete(tmp);
 	  }
           if (templateparms) {
 	    Parm *tmp = CopyParmList(templateparms);
-	    Setattr(new_function,"templateparms",tmp);
+	    Setattr(new_function,k_templateparms,tmp);
 	    Delete(tmp);
 	  }
         } else if (strcmp(cntype,"constructor") == 0) {
@@ -1422,18 +1423,18 @@ static void default_arguments(Node *n) {
 
 program        :  interface {
 		   Setattr($1,"classes",classes); 
-		   Setattr($1,"name",ModuleName);
+		   Setattr($1,k_name,ModuleName);
 		   
 		   if ((!module_node) && ModuleName) {
 		     module_node = new_node("module");
-		     Setattr(module_node,"name",ModuleName);
+		     Setattr(module_node,k_name,ModuleName);
 		   }
 		   Setattr($1,"module",module_node);
 		   check_extensions();
 	           top = $1;
                }
                | PARSETYPE parm SEMI {
-                 top = Copy(Getattr($2,"type"));
+                 top = Copy(Getattr($2,k_type));
 		 Delete($2);
                }
                | PARSETYPE error {
@@ -1542,12 +1543,12 @@ extend_directive : EXTEND options idcolon LBRACE {
 		   Swig_symbol_setscopename($3);
 		   prev_symtab = 0;
 		 } else {
-		   prev_symtab = Swig_symbol_setscope(Getattr(am,"symtab"));
+		   prev_symtab = Swig_symbol_setscope(Getattr(am,k_symtab));
 		 }
 		 current_class = 0;
 	       } else {
 		 /* Previous class definition.  Use its symbol table */
-		 prev_symtab = Swig_symbol_setscope(Getattr(cls,"symtab"));
+		 prev_symtab = Swig_symbol_setscope(Getattr(cls,k_symtab));
 		 current_class = cls;
 		 extendmode = 1;
 	       }
@@ -1558,13 +1559,13 @@ extend_directive : EXTEND options idcolon LBRACE {
                String *clsname;
 	       extendmode = 0;
                $$ = new_node("extend");
-	       Setattr($$,"symtab",Swig_symbol_popscope());
+	       Setattr($$,k_symtab,Swig_symbol_popscope());
 	       if (prev_symtab) {
 		 Swig_symbol_setscope(prev_symtab);
 	       }
 	       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
                clsname = make_class_name($3);
-	       Setattr($$,"name",clsname);
+	       Setattr($$,k_name,clsname);
 
 	       /* Mark members as extend */
 
@@ -1600,7 +1601,7 @@ extend_directive : EXTEND options idcolon LBRACE {
 
 apply_directive : APPLY typemap_parm LBRACE tm_list RBRACE {
                     $$ = new_node("apply");
-                    Setattr($$,"pattern",Getattr($2,"pattern"));
+                    Setattr($$,k_pattern,Getattr($2,k_pattern));
 		    appendChild($$,$4);
                };
 
@@ -1623,11 +1624,11 @@ constant_directive :  CONSTANT ID EQUAL definetype SEMI {
 		   if (($4.type != T_ERROR) && ($4.type != T_SYMBOL)) {
 		     SwigType *type = NewSwigType($4.type);
 		     $$ = new_node("constant");
-		     Setattr($$,"name",$2);
-		     Setattr($$,"type",type);
-		     Setattr($$,"value",$4.val);
+		     Setattr($$,k_name,$2);
+		     Setattr($$,k_type,type);
+		     Setattr($$,k_value,$4.val);
 		     if ($4.rawval) Setattr($$,"rawval", $4.rawval);
-		     Setattr($$,"storage","%constant");
+		     Setattr($$,k_storage,"%constant");
 		     SetFlag($$,"feature:immutable");
 		     add_symbols($$);
 		     Delete(type);
@@ -1648,11 +1649,11 @@ constant_directive :  CONSTANT ID EQUAL definetype SEMI {
 		     SwigType_add_pointer($2);
 		   }
 		   $$ = new_node("constant");
-		   Setattr($$,"name",$3.id);
-		   Setattr($$,"type",$2);
-		   Setattr($$,"value",$4.val);
+		   Setattr($$,k_name,$3.id);
+		   Setattr($$,k_type,$2);
+		   Setattr($$,k_value,$4.val);
 		   if ($4.rawval) Setattr($$,"rawval", $4.rawval);
-		   Setattr($$,"storage","%constant");
+		   Setattr($$,k_storage,"%constant");
 		   SetFlag($$,"feature:immutable");
 		   add_symbols($$);
 		 } else {
@@ -1731,14 +1732,14 @@ except_directive : EXCEPT LPAREN ID RPAREN LBRACE {
 /* fragment keyword arguments */
 stringtype    : string LBRACE parm RBRACE {		 
                  $$ = NewHash();
-                 Setattr($$,"value",$1);
-		 Setattr($$,"type",Getattr($3,"type"));
+                 Setattr($$,k_value,$1);
+		 Setattr($$,k_type,Getattr($3,k_type));
                }
                ;
 
 fname         : string {
                  $$ = NewHash();
-                 Setattr($$,"value",$1);
+                 Setattr($$,k_value,$1);
               }
               | stringtype {
                 $$ = $1;
@@ -1748,31 +1749,31 @@ fname         : string {
 fragment_directive: FRAGMENT LPAREN fname COMMA kwargs RPAREN HBLOCK {
                    Hash *p = $5;
 		   $$ = new_node("fragment");
-		   Setattr($$,"value",Getattr($3,"value"));
-		   Setattr($$,"type",Getattr($3,"type"));
-		   Setattr($$,"section",Getattr(p,"name"));
-		   Setattr($$,"kwargs",nextSibling(p));
-		   Setattr($$,"code",$7);
+		   Setattr($$,k_value,Getattr($3,k_value));
+		   Setattr($$,k_type,Getattr($3,k_type));
+		   Setattr($$,k_section,Getattr(p,k_name));
+		   Setattr($$,k_kwargs,nextSibling(p));
+		   Setattr($$,k_code,$7);
                  }
                  | FRAGMENT LPAREN fname COMMA kwargs RPAREN LBRACE {
 		   Hash *p = $5;
 		   String *code;
                    skip_balanced('{','}');
 		   $$ = new_node("fragment");
-		   Setattr($$,"value",Getattr($3,"value"));
-		   Setattr($$,"type",Getattr($3,"type"));
-		   Setattr($$,"section",Getattr(p,"name"));
-		   Setattr($$,"kwargs",nextSibling(p));
+		   Setattr($$,k_value,Getattr($3,k_value));
+		   Setattr($$,k_type,Getattr($3,k_type));
+		   Setattr($$,k_section,Getattr(p,k_name));
+		   Setattr($$,k_kwargs,nextSibling(p));
 		   Delitem(scanner_ccode,0);
 		   Delitem(scanner_ccode,DOH_END);
 		   code = Copy(scanner_ccode);
-		   Setattr($$,"code",code);
+		   Setattr($$,k_code,code);
 		   Delete(code);
                  }
                  | FRAGMENT LPAREN fname RPAREN SEMI {
 		   $$ = new_node("fragment");
-		   Setattr($$,"value",Getattr($3,"value"));
-		   Setattr($$,"type",Getattr($3,"type"));
+		   Setattr($$,k_value,Getattr($3,k_value));
+		   Setattr($$,k_type,Getattr($3,k_type));
 		   Setattr($$,"emitonly","1");
 		 }
                  ;
@@ -1799,17 +1800,17 @@ include_directive: includetype options string LBRACKET {
 		       if (import_mode) --import_mode;
 		     }
 		     
-		     Setattr($$,"name",$3);
+		     Setattr($$,k_name,$3);
 		     /* Search for the module (if any) */
 		     {
 			 Node *n = firstChild($$);
 			 while (n) {
 			     if (Strcmp(nodeType(n),"module") == 0) {
 			         if (mname) {
-				   Setattr(n,"name", mname);
+				   Setattr(n,k_name, mname);
 				   mname = 0;
 				 }
-				 Setattr($$,"module",Getattr(n,"name"));
+				 Setattr($$,"module",Getattr(n,k_name));
 				 break;
 			     }
 			     n = nextSibling(n);
@@ -1822,7 +1823,7 @@ include_directive: includetype options string LBRACKET {
 			   */			      
 			   Node *nint = new_node("import");
 			   Node *mnode = new_node("module");
-			   Setattr(mnode,"name", mname);
+			   Setattr(mnode,k_name, mname);
 			   appendChild(nint,mnode);
 			   Delete(mnode);
 			   appendChild(nint,firstChild($$));
@@ -1850,7 +1851,7 @@ inline_directive : INLINE HBLOCK {
 		   $$ = 0;
 		 } else {
 		   $$ = new_node("insert");
-		   Setattr($$,"code",$2);
+		   Setattr($$,k_code,$2);
 		   /* Need to run through the preprocessor */
 		   Setline($2,cparse_start_line);
 		   Setfile($2,cparse_file);
@@ -1876,7 +1877,7 @@ inline_directive : INLINE HBLOCK {
 		   Delitem(scanner_ccode,0);
 		   Delitem(scanner_ccode,DOH_END);
 		   code = Copy(scanner_ccode);
-		   Setattr($$,"code", code);
+		   Setattr($$,k_code, code);
 		   Delete(code);		   
 		   cpps=Copy(scanner_ccode);
 		   start_inline(Char(cpps), start_line);
@@ -1895,13 +1896,13 @@ inline_directive : INLINE HBLOCK {
 
 insert_directive : HBLOCK {
                  $$ = new_node("insert");
-		 Setattr($$,"code",$1);
+		 Setattr($$,k_code,$1);
 	       }
                | INSERT LPAREN idstring RPAREN string {
 		 String *code = NewStringEmpty();
 		 $$ = new_node("insert");
-		 Setattr($$,"section",$3);
-		 Setattr($$,"code",code);
+		 Setattr($$,k_section,$3);
+		 Setattr($$,k_code,code);
 		 if (Swig_insert_file($5,code) < 0) {
 		   Swig_error(cparse_file, cparse_line, "Couldn't find '%s'.\n", $5);
 		   $$ = 0;
@@ -1909,18 +1910,18 @@ insert_directive : HBLOCK {
                }
                | INSERT LPAREN idstring RPAREN HBLOCK {
 		 $$ = new_node("insert");
-		 Setattr($$,"section",$3);
-		 Setattr($$,"code",$5);
+		 Setattr($$,k_section,$3);
+		 Setattr($$,k_code,$5);
                }
                | INSERT LPAREN idstring RPAREN LBRACE {
 		 String *code;
                  skip_balanced('{','}');
 		 $$ = new_node("insert");
-		 Setattr($$,"section",$3);
+		 Setattr($$,k_section,$3);
 		 Delitem(scanner_ccode,0);
 		 Delitem(scanner_ccode,DOH_END);
 		 code = Copy(scanner_ccode);
-		 Setattr($$,"code", code);
+		 Setattr($$,k_code, code);
 		 Delete(code);
 	       }
                ;
@@ -1949,11 +1950,11 @@ module_directive: MODULE options idstring {
 		   /* first module included, we apply global
 		      ModuleName, which can be modify by -module */
 		   String *mname = Copy(ModuleName);
-		   Setattr($$,"name",mname);
+		   Setattr($$,k_name,mname);
 		   Delete(mname);
 		 } else { 
 		   /* import mode, we just pass the idstring */
-		   Setattr($$,"name",$3);   
+		   Setattr($$,k_name,$3);   
 		 }		 
 		 if (!module_node) module_node = $$;
 	       }
@@ -1985,7 +1986,7 @@ name_directive : NAME LPAREN idstring RPAREN {
 
 native_directive : NATIVE LPAREN ID RPAREN storage_class ID SEMI {
                  $$ = new_node("native");
-		 Setattr($$,"name",$3);
+		 Setattr($$,k_name,$3);
 		 Setattr($$,"wrap:name",$6);
 	         add_symbols($$);
 	       }
@@ -1998,11 +1999,11 @@ native_directive : NATIVE LPAREN ID RPAREN storage_class ID SEMI {
 		     /* Need check for function here */
 		     SwigType_push($6,$7.type);
 		     $$ = new_node("native");
-	             Setattr($$,"name",$3);
+	             Setattr($$,k_name,$3);
 		     Setattr($$,"wrap:name",$7.id);
-		     Setattr($$,"type",$6);
-		     Setattr($$,"parms",$7.parms);
-		     Setattr($$,"decl",$7.type);
+		     Setattr($$,k_type,$6);
+		     Setattr($$,k_parms,$7.parms);
+		     Setattr($$,k_decl,$7.type);
 		 }
 	         add_symbols($$);
 	       }
@@ -2018,13 +2019,13 @@ native_directive : NATIVE LPAREN ID RPAREN storage_class ID SEMI {
 pragma_directive : PRAGMA pragma_lang ID EQUAL pragma_arg {
                  $$ = new_node("pragma");
 		 Setattr($$,"lang",$2);
-		 Setattr($$,"name",$3);
-		 Setattr($$,"value",$5);
+		 Setattr($$,k_name,$3);
+		 Setattr($$,k_value,$5);
 	       }
               | PRAGMA pragma_lang ID {
 		$$ = new_node("pragma");
 		Setattr($$,"lang",$2);
-		Setattr($$,"name",$3);
+		Setattr($$,k_name,$3);
 	      }
               ;
 
@@ -2044,7 +2045,7 @@ pragma_lang   : LPAREN ID RPAREN { $$ = $2; }
 rename_directive : rename_namewarn declarator idstring SEMI {
                     SwigType *t = $2.type;
 		    Hash *kws = NewHash();
-		    Setattr(kws,"name",$3);
+		    Setattr(kws,k_name,$3);
 
 		    if (!Len(t)) t = 0;
 		    if ($1) {
@@ -2192,13 +2193,13 @@ stringbracesemi : stringbrace { $$ = $1; }
 
 featattr        : COMMA idstring EQUAL stringnum {
 		  $$ = NewHash();
-		  Setattr($$,"name",$2);
-		  Setattr($$,"value",$4);
+		  Setattr($$,k_name,$2);
+		  Setattr($$,k_value,$4);
                 }
                 | COMMA idstring EQUAL stringnum featattr {
 		  $$ = NewHash();
-		  Setattr($$,"name",$2);
-		  Setattr($$,"value",$4);
+		  Setattr($$,k_name,$2);
+		  Setattr($$,k_value,$4);
                   set_nextSibling($$,$5);
                 }
 		;
@@ -2213,7 +2214,7 @@ varargs_directive : VARARGS LPAREN varargs_parms RPAREN declarator cpp_const SEM
 		 else name = NewString($5.id);
 		 val = $3;
 		 if ($5.parms) {
-		   Setmeta(val,"parms",$5.parms);
+		   Setmeta(val,k_parms,$5.parms);
 		 }
 		 t = $5.type;
 		 if (!Len(t)) t = 0;
@@ -2252,7 +2253,7 @@ varargs_parms   : parms { $$ = $1; }
 		    $$ = 0;
 		  } else {
 		    $$ = Copy($3);
-		    Setattr($$,"name","VARARGS_SENTINEL");
+		    Setattr($$,k_name,"VARARGS_SENTINEL");
 		    for (i = 0; i < n; i++) {
 		      p = Copy($3);
 		      set_nextSibling(p,$$);
@@ -2282,7 +2283,7 @@ typemap_directive :  TYPEMAP LPAREN typemap_type RPAREN tm_list stringbrace {
 		       Parm *kw = $3.kwargs;
 		       /* check for 'noblock' option, which remove the block braces */
 		       while (kw) {
-			 String *name = Getattr(kw,"name");
+			 String *name = Getattr(kw,k_name);
 			 if (name && (Cmp(name,"noblock") == 0)) {
 			   char *cstr = Char($6);
 			   size_t len = Len($6);
@@ -2298,10 +2299,10 @@ typemap_directive :  TYPEMAP LPAREN typemap_type RPAREN tm_list stringbrace {
 			 }
 			 kw = nextSibling(kw);
 		       }
-		       Setattr($$,"kwargs", $3.kwargs);
+		       Setattr($$,k_kwargs, $3.kwargs);
 		     }
 		     code = code ? code : NewString($6);
-		     Setattr($$,"code", code);
+		     Setattr($$,k_code, code);
 		     Delete(code);
 		     appendChild($$,$5);
 		   }
@@ -2319,7 +2320,7 @@ typemap_directive :  TYPEMAP LPAREN typemap_type RPAREN tm_list stringbrace {
 		   if ($3.op) {
 		     $$ = new_node("typemapcopy");
 		     Setattr($$,"method",$3.op);
-		     Setattr($$,"pattern", Getattr($7,"pattern"));
+		     Setattr($$,k_pattern, Getattr($7,k_pattern));
 		     appendChild($$,$5);
 		   }
 	       }
@@ -2331,19 +2332,19 @@ typemap_type   : kwargs {
 		 Hash *p;
 		 String *name;
 		 p = nextSibling($1);
-		 if (p && (!Getattr(p,"value"))) {
+		 if (p && (!Getattr(p,k_value))) {
 		   /* two argument typemap form */
-		   name = Getattr($1,"name");
+		   name = Getattr($1,k_name);
 		   if (!name || (Strcmp(name,typemap_lang))) {
 		     $$.op = 0;
 		     $$.kwargs = 0;
 		   } else {
-		     $$.op = Getattr(p,"name");
+		     $$.op = Getattr(p,k_name);
 		     $$.kwargs = nextSibling(p);
 		   }
 		 } else {
 		   /* one-argument typemap-form */
-		   $$.op = Getattr($1,"name");
+		   $$.op = Getattr($1,k_name);
 		   $$.kwargs = p;
 		 }
                 }
@@ -2367,22 +2368,22 @@ typemap_parm   : type typemap_parameter_declarator {
 		  SwigType_push($1,$2.type);
 		  $$ = new_node("typemapitem");
 		  parm = NewParm($1,$2.id);
-		  Setattr($$,"pattern",parm);
-		  Setattr($$,"parms", $2.parms);
+		  Setattr($$,k_pattern,parm);
+		  Setattr($$,k_parms, $2.parms);
 		  Delete(parm);
 		  /*		  $$ = NewParm($1,$2.id);
 				  Setattr($$,"parms",$2.parms); */
                 }
                | LPAREN parms RPAREN {
                   $$ = new_node("typemapitem");
-		  Setattr($$,"pattern",$2);
+		  Setattr($$,k_pattern,$2);
 		  /*		  Setattr($$,"multitype",$2); */
                }
                | LPAREN parms RPAREN LPAREN parms RPAREN {
 		 $$ = new_node("typemapitem");
-		 Setattr($$,"pattern", $2);
+		 Setattr($$,k_pattern, $2);
 		 /*                 Setattr($$,"multitype",$2); */
-		 Setattr($$,"parms",$5);
+		 Setattr($$,k_parms,$5);
                }
                ;
 
@@ -2392,7 +2393,7 @@ typemap_parm   : type typemap_parameter_declarator {
 
 types_directive : TYPES LPAREN parms RPAREN SEMI {
                    $$ = new_node("types");
-		   Setattr($$,"parms",$3);
+		   Setattr($$,k_parms,$3);
                }
                ;
 
@@ -2426,25 +2427,25 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
 		  /* Patch the argument types to respect namespaces */
 		  p = $7;
 		  while (p) {
-		    SwigType *value = Getattr(p,"value");
+		    SwigType *value = Getattr(p,k_value);
 		    if (!value) {
-		      SwigType *ty = Getattr(p,"type");
+		      SwigType *ty = Getattr(p,k_type);
 		      if (ty) {
 			if (template_reduce) {
 			  SwigType *rty = Swig_symbol_typedef_reduce(ty,tscope);
 			  ty = Swig_symbol_type_qualify(rty,tscope);
-			  Setattr(p,"type",ty);
+			  Setattr(p,k_type,ty);
 			  Delete(ty);
 			  Delete(rty);
 			} else {
 			  ty = Swig_symbol_type_qualify(ty,tscope);
-			  Setattr(p,"type",ty);
+			  Setattr(p,k_type,ty);
 			  Delete(ty);
 			}
 		      }
 		    } else {
 		      value = Swig_symbol_type_qualify(value,tscope);
-		      Setattr(p,"value",value);
+		      Setattr(p,k_value,value);
 		      Delete(value);
 		    }
 		    
@@ -2458,8 +2459,8 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
                     while (nn) {
                       Node *templnode = 0;
                       if (Strcmp(nodeType(nn),"template") == 0) {
-                        int nnisclass = (Strcmp(Getattr(nn,"templatetype"),"class") == 0); /* if not a templated class it is a templated function */
-                        Parm *tparms = Getattr(nn,"templateparms");
+                        int nnisclass = (Strcmp(Getattr(nn,k_templatetype),"class") == 0); /* if not a templated class it is a templated function */
+                        Parm *tparms = Getattr(nn,k_templateparms);
                         if (!tparms) {
                           specialized = 1;
                         }
@@ -2476,7 +2477,7 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
                           int  def_supplied = 0;
                           /* Expand the template */
 			  Node *templ = Swig_symbol_clookup($5,0);
-			  Parm *targs = templ ? Getattr(templ,"templateparms") : 0;
+			  Parm *targs = templ ? Getattr(templ,k_templateparms) : 0;
 
                           ParmList *temparms;
                           if (specialized) temparms = CopyParmList($7);
@@ -2486,29 +2487,29 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
                           p = $7;
                           tp = temparms;
                           while (p) {
-                            String *value = Getattr(p,"value");
+                            String *value = Getattr(p,k_value);
                             if (def_supplied) {
                               Setattr(p,"default","1");
                             }
                             if (value) {
-                              Setattr(tp,"value",value);
+                              Setattr(tp,k_value,value);
                             } else {
-                              SwigType *ty = Getattr(p,"type");
+                              SwigType *ty = Getattr(p,k_type);
                               if (ty) {
-                                Setattr(tp,"type",ty);
+                                Setattr(tp,k_type,ty);
                               }
-                              Delattr(tp,"value");
+                              Delattr(tp,k_value);
                             }
 			    /* fix default arg values */
 			    if (targs) {
 			      Parm *pi = temparms;
 			      Parm *ti = targs;
-			      String *tv = Getattr(tp,"value");
-			      if (!tv) tv = Getattr(tp,"type");
+			      String *tv = Getattr(tp,k_value);
+			      if (!tv) tv = Getattr(tp,k_type);
 			      while(pi != tp) {
-				String *name = Getattr(ti,"name");
-				String *value = Getattr(pi,"value");
-				if (!value) value = Getattr(pi,"type");
+				String *name = Getattr(ti,k_name);
+				String *value = Getattr(pi,k_value);
+				if (!value) value = Getattr(pi,k_type);
 				Replaceid(tv, name, value);
 				pi = nextSibling(pi);
 				ti = nextSibling(ti);
@@ -2524,27 +2525,27 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
 
                           templnode = copy_node(nn);
                           /* We need to set the node name based on name used to instantiate */
-                          Setattr(templnode,"name",tname);
+                          Setattr(templnode,k_name,tname);
 			  Delete(tname);
                           if (!specialized) {
-                            Delattr(templnode,"sym:typename");
+                            Delattr(templnode,k_symtypename);
                           } else {
-                            Setattr(templnode,"sym:typename","1");
+                            Setattr(templnode,k_symtypename,"1");
                           }
                           if ($3) {
                             Swig_cparse_template_expand(templnode,$3,temparms,tscope);
-                            Setattr(templnode,"sym:name",$3);
+                            Setattr(templnode,k_symname,$3);
                           } else {
                             static int cnt = 0;
                             String *nname = NewStringf("__dummy_%d__", cnt++);
                             Swig_cparse_template_expand(templnode,nname,temparms,tscope);
-                            Setattr(templnode,"sym:name",nname);
+                            Setattr(templnode,k_symname,nname);
 			    Delete(nname);
                             Setattr(templnode,"feature:onlychildren",
                                     "typemap,typemapitem,typemapcopy,typedef,types,fragment");
                           }
-                          Delattr(templnode,"templatetype");
-                          Setattr(templnode,"template",nn);
+                          Delattr(templnode,k_templatetype);
+                          Setattr(templnode,k_template,nn);
                           tnode = templnode;
                           Setfile(templnode,cparse_file);
                           Setline(templnode,cparse_line);
@@ -2555,20 +2556,20 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
                           if (Strcmp(nodeType(templnode),"class") == 0) {
 
                             /* Identify pure abstract methods */
-                            Setattr(templnode,"abstract", pure_abstract(firstChild(templnode)));
+                            Setattr(templnode,k_abstract, pure_abstract(firstChild(templnode)));
                             
                             /* Set up inheritance in symbol table */
                             {
                               Symtab  *csyms;
-                              List *baselist = Getattr(templnode,"baselist");
+                              List *baselist = Getattr(templnode,k_baselist);
                               csyms = Swig_symbol_current();
-                              Swig_symbol_setscope(Getattr(templnode,"symtab"));
+                              Swig_symbol_setscope(Getattr(templnode,k_symtab));
                               if (baselist) {
-                                List *bases = make_inherit_list(Getattr(templnode,"name"),baselist);
+                                List *bases = make_inherit_list(Getattr(templnode,k_name),baselist);
                                 if (bases) {
                                   Iterator s;
                                   for (s = First(bases); s.item; s = Next(s)) {
-                                    Symtab *st = Getattr(s.item,"symtab");
+                                    Symtab *st = Getattr(s.item,k_symtab);
                                     if (st) {
                                       Swig_symbol_inherit(st);
                                     }
@@ -2589,15 +2590,15 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
                               String *clsname;
                               Node *am;
                               if (Namespaceprefix) {
-                                clsname = stmp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+                                clsname = stmp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,k_name));
                               } else {
-                                clsname = Getattr(templnode,"name");
+                                clsname = Getattr(templnode,k_name);
                               }
                               am = Getattr(extendhash,clsname);
                               if (am) {
                                 Symtab *st = Swig_symbol_current();
-                                Swig_symbol_setscope(Getattr(templnode,"symtab"));
-                                /*			    Printf(stdout,"%s: %s %x %x\n", Getattr(templnode,"name"), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */
+                                Swig_symbol_setscope(Getattr(templnode,k_symtab));
+                                /*			    Printf(stdout,"%s: %s %x %x\n", Getattr(templnode,k_name), clsname, Swig_symbol_current(), Getattr(templnode,"symtab")); */
                                 merge_extensions(templnode,am);
                                 Swig_symbol_setscope(st);
 				append_previous_extension(templnode,am);
@@ -2610,7 +2611,7 @@ template_directive: SWIGTEMPLATE LPAREN idstringopt RPAREN idcolonnt LESSTHAN va
 
                             {
                               if (Namespaceprefix) {
-                                String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,"name"));
+                                String *temp = NewStringf("%s::%s", Namespaceprefix, Getattr(templnode,k_name));
                                 Setattr(classes,temp,templnode);
 				Delete(temp);
                               } else {
@@ -2686,19 +2687,19 @@ c_declaration   : c_decl {
 		  if (Strcmp($2,"C") == 0) {
 		    Node *n = firstChild($5);
 		    $$ = new_node("extern");
-		    Setattr($$,"name",$2);
+		    Setattr($$,k_name,$2);
 		    appendChild($$,n);
 		    while (n) {
-		      SwigType *decl = Getattr(n,"decl");
+		      SwigType *decl = Getattr(n,k_decl);
 		      if (SwigType_isfunction(decl)) {
-			Setattr(n,"storage","externc");
+			Setattr(n,k_storage,"externc");
 		      }
 		      n = nextSibling(n);
 		    }
 		  } else {
 		     Swig_warning(WARN_PARSE_UNDEFINED_EXTERN,cparse_file, cparse_line,"Unrecognized extern type \"%s\".\n", $2);
 		    $$ = new_node("extern");
-		    Setattr($$,"name",$2);
+		    Setattr($$,k_name,$2);
 		    appendChild($$,firstChild($5));
 		  }
                 }
@@ -2711,18 +2712,18 @@ c_declaration   : c_decl {
 c_decl  : storage_class type declarator initializer c_decl_tail {
               $$ = new_node("cdecl");
 	      if ($4.qualifier) SwigType_push($3.type,$4.qualifier);
-	      Setattr($$,"type",$2);
-	      Setattr($$,"storage",$1);
-	      Setattr($$,"name",$3.id);
-	      Setattr($$,"decl",$3.type);
-	      Setattr($$,"parms",$3.parms);
-	      Setattr($$,"value",$4.val);
-	      Setattr($$,"throws",$4.throws);
-	      Setattr($$,"throw",$4.throwf);
+	      Setattr($$,k_type,$2);
+	      Setattr($$,k_storage,$1);
+	      Setattr($$,k_name,$3.id);
+	      Setattr($$,k_decl,$3.type);
+	      Setattr($$,k_parms,$3.parms);
+	      Setattr($$,k_value,$4.val);
+	      Setattr($$,k_throws,$4.throws);
+	      Setattr($$,k_throw,$4.throwf);
 	      if (!$5) {
 		if (Len(scanner_ccode)) {
 		  String *code = Copy(scanner_ccode);
-		  Setattr($$,"code",code);
+		  Setattr($$,k_code,code);
 		  Delete(code);
 		}
 	      } else {
@@ -2730,8 +2731,8 @@ c_decl  : storage_class type declarator initializer c_decl_tail {
 		/* Inherit attributes */
 		while (n) {
 		  String *type = Copy($2);
-		  Setattr(n,"type",type);
-		  Setattr(n,"storage",$1);
+		  Setattr(n,k_type,type);
+		  Setattr(n,k_storage,$1);
 		  n = nextSibling(n);
 		  Delete(type);
 		}
@@ -2749,7 +2750,7 @@ c_decl  : storage_class type declarator initializer c_decl_tail {
 		  if ((Namespaceprefix && Strcmp(p,Namespaceprefix) == 0) ||
 		      (inclass && Strcmp(p,Classprefix) == 0)) {
 		    String *lstr = Swig_scopename_last($3.id);
-		    Setattr($$,"name",lstr);
+		    Setattr($$,k_name,lstr);
 		    Delete(lstr);
 		    set_nextSibling($$,$5);
 		  } else {
@@ -2776,19 +2777,19 @@ c_decl_tail    : SEMI {
                | COMMA declarator initializer c_decl_tail {
 		 $$ = new_node("cdecl");
 		 if ($3.qualifier) SwigType_push($2.type,$3.qualifier);
-		 Setattr($$,"name",$2.id);
-		 Setattr($$,"decl",$2.type);
-		 Setattr($$,"parms",$2.parms);
-		 Setattr($$,"value",$3.val);
-		 Setattr($$,"throws",$3.throws);
-		 Setattr($$,"throw",$3.throwf);
+		 Setattr($$,k_name,$2.id);
+		 Setattr($$,k_decl,$2.type);
+		 Setattr($$,k_parms,$2.parms);
+		 Setattr($$,k_value,$3.val);
+		 Setattr($$,k_throws,$3.throws);
+		 Setattr($$,k_throw,$3.throwf);
 		 if ($3.bitfield) {
 		   Setattr($$,"bitfield", $3.bitfield);
 		 }
 		 if (!$4) {
 		   if (Len(scanner_ccode)) {
 		     String *code = Copy(scanner_ccode);
-		     Setattr($$,"code",code);
+		     Setattr($$,k_code,code);
 		     Delete(code);
 		   }
 		 } else {
@@ -2836,9 +2837,9 @@ c_enum_forward_decl : storage_class ENUM ID SEMI {
 		   SwigType *ty = 0;
 		   $$ = new_node("enumforward");
 		   ty = NewStringf("enum %s", $3);
-		   Setattr($$,"name",$3);
-		   Setattr($$,"type",ty);
-		   Setattr($$,"sym:weak", "1");
+		   Setattr($$,k_name,$3);
+		   Setattr($$,k_type,ty);
+		   Setattr($$,k_symweak, "1");
 		   add_symbols($$);
 	      }
               ;
@@ -2851,8 +2852,8 @@ c_enum_decl : storage_class ENUM ename LBRACE enumlist RBRACE SEMI {
 		  SwigType *ty = 0;
                   $$ = new_node("enum");
 		  ty = NewStringf("enum %s", $3);
-		  Setattr($$,"name",$3);
-		  Setattr($$,"type",ty);
+		  Setattr($$,k_name,$3);
+		  Setattr($$,k_type,ty);
 		  appendChild($$,$5);
 		  add_symbols($$);       /* Add to tag space */
 		  add_symbols($5);       /* Add enum values to id space */
@@ -2865,19 +2866,19 @@ c_enum_decl : storage_class ENUM ename LBRACE enumlist RBRACE SEMI {
 
 		 $$ = new_node("enum");
 		 if ($3) {
-		   Setattr($$,"name",$3);
+		   Setattr($$,k_name,$3);
 		   ty = NewStringf("enum %s", $3);
 		 } else if ($7.id) {
 		   unnamed = make_unnamed();
 		   ty = NewStringf("enum %s", unnamed);
-		   Setattr($$,"unnamed",unnamed);
+		   Setattr($$,k_unnamed,unnamed);
                    /* name is not set for unnamed enum instances, e.g. enum { foo } Instance; */
 		   if ($1 && Cmp($1,"typedef") == 0) {
-		     Setattr($$,"name",$7.id);
+		     Setattr($$,k_name,$7.id);
                    } else {
                      unnamedinstance = 1;
                    }
-		   Setattr($$,"storage",$1);
+		   Setattr($$,k_storage,$1);
 		 }
 		 if ($7.id && Cmp($1,"typedef") == 0) {
 		   Setattr($$,"tdname",$7.id);
@@ -2885,16 +2886,16 @@ c_enum_decl : storage_class ENUM ename LBRACE enumlist RBRACE SEMI {
                  }
 		 appendChild($$,$5);
 		 n = new_node("cdecl");
-		 Setattr(n,"type",ty);
-		 Setattr(n,"name",$7.id);
-		 Setattr(n,"storage",$1);
-		 Setattr(n,"decl",$7.type);
-		 Setattr(n,"parms",$7.parms);
-		 Setattr(n,"unnamed",unnamed);
+		 Setattr(n,k_type,ty);
+		 Setattr(n,k_name,$7.id);
+		 Setattr(n,k_storage,$1);
+		 Setattr(n,k_decl,$7.type);
+		 Setattr(n,k_parms,$7.parms);
+		 Setattr(n,k_unnamed,unnamed);
 
                  if (unnamedinstance) {
 		   SwigType *cty = NewString("enum ");
-		   Setattr($$,"type",cty);
+		   Setattr($$,k_type,cty);
 		   Setattr($$,"unnamedinstance","1");
 		   Setattr(n,"unnamedinstance","1");
 		   Delete(cty);
@@ -2904,16 +2905,16 @@ c_enum_decl : storage_class ENUM ename LBRACE enumlist RBRACE SEMI {
 		   set_nextSibling(n,p);
 		   while (p) {
 		     SwigType *cty = Copy(ty);
-		     Setattr(p,"type",cty);
-		     Setattr(p,"unnamed",unnamed);
-		     Setattr(p,"storage",$1);
+		     Setattr(p,k_type,cty);
+		     Setattr(p,k_unnamed,unnamed);
+		     Setattr(p,k_storage,$1);
 		     Delete(cty);
 		     p = nextSibling(p);
 		   }
 		 } else {
 		   if (Len(scanner_ccode)) {
 		     String *code = Copy(scanner_ccode);
-		     Setattr(n,"code",code);
+		     Setattr(n,k_code,code);
 		     Delete(code);
 		   }
 		 }
@@ -2947,31 +2948,31 @@ c_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
                     $$ = 0;
 
 		    if ((ParmList_len($4) == 1) && (!Swig_scopename_check($2))) {
-		      SwigType *ty = Getattr($4,"type");
-		      String *name = Getattr($4,"name");
+		      SwigType *ty = Getattr($4,k_type);
+		      String *name = Getattr($4,k_name);
 		      err = 1;
 		      if (!name) {
 			$$ = new_node("cdecl");
-			Setattr($$,"type",$2);
-			Setattr($$,"storage",$1);
-			Setattr($$,"name",ty);
+			Setattr($$,k_type,$2);
+			Setattr($$,k_storage,$1);
+			Setattr($$,k_name,ty);
 
 			if ($6.have_parms) {
 			  SwigType *decl = NewStringEmpty();
 			  SwigType_add_function(decl,$6.parms);
-			  Setattr($$,"decl",decl);
-			  Setattr($$,"parms",$6.parms);
+			  Setattr($$,k_decl,decl);
+			  Setattr($$,k_parms,$6.parms);
 			  if (Len(scanner_ccode)) {
 			    String *code = Copy(scanner_ccode);
-			    Setattr($$,"code",code);
+			    Setattr($$,k_code,code);
 			    Delete(code);
 			  }
 			}
 			if ($6.defarg) {
-			  Setattr($$,"value",$6.defarg);
+			  Setattr($$,k_value,$6.defarg);
 			}
-			Setattr($$,"throws",$6.throws);
-			Setattr($$,"throw",$6.throwf);
+			Setattr($$,k_throws,$6.throws);
+			Setattr($$,k_throw,$6.throwf);
 			err = 0;
 		      }
 		    }
@@ -3061,7 +3062,7 @@ cpp_class_decl  :
 		   if (bases) {
 		     Iterator s;
 		     for (s = First(bases); s.item; s = Next(s)) {
-		       Symtab *st = Getattr(s.item,"symtab");
+		       Symtab *st = Getattr(s.item,k_symtab);
 		       if (st) {
 			 Swig_symbol_inherit(st); 
 		       }
@@ -3078,9 +3079,9 @@ cpp_class_decl  :
 		   if (template_parameters) {
 		     Parm *tp = template_parameters;
 		     while(tp) {
-		       String *tpname = Copy(Getattr(tp,"name"));
+		       String *tpname = Copy(Getattr(tp,k_name));
 		       Node *tn = new_node("templateparm");
-		       Setattr(tn,"name",tpname);
+		       Setattr(tn,k_name,tpname);
 		       Swig_symbol_cadd(tpname,tn);
 		       tp = nextSibling(tp);
 		       Delete(tpname);
@@ -3096,16 +3097,16 @@ cpp_class_decl  :
 		 inclass = 0;
 		 $$ = new_node("class");
 		 Setline($$,cparse_start_line);
-		 Setattr($$,"name",$3);
-		 Setattr($$,"kind",$2);
+		 Setattr($$,k_name,$3);
+		 Setattr($$,k_kind,$2);
 		 if ($4) {
-		   Setattr($$,"baselist", Getattr($4,"public"));
+		   Setattr($$,k_baselist, Getattr($4,"public"));
 		   Setattr($$,"protectedbaselist", Getattr($4,"protected"));
 		   Setattr($$,"privatebaselist", Getattr($4,"private"));
 		 }
 		 Setattr($$,"allows_typedef","1");
 		 /* Check for pure-abstract class */
-		 Setattr($$,"abstract", pure_abstract($7));
+		 Setattr($$,k_abstract, pure_abstract($7));
 		 
 		 /* This bit of code merges in a previously defined %extend directive (if any) */
 		 
@@ -3138,19 +3139,19 @@ cpp_class_decl  :
 		   ty = NewStringf("%s %s", $2,$3);
 		 }
 		 while (p) {
-		   Setattr(p,"storage",$1);
-		   Setattr(p,"type",ty);
+		   Setattr(p,k_storage,$1);
+		   Setattr(p,k_type,ty);
 		   p = nextSibling(p);
 		 }
 		 /* Dump nested classes */
 		 {
 		   String *name = $3;
 		   if ($9) {
-		     SwigType *decltype = Getattr($9,"decl");
+		     SwigType *decltype = Getattr($9,k_decl);
 		     if (Cmp($1,"typedef") == 0) {
 		       if (!decltype || !Len(decltype)) {
 			 String *cname;
-			 name = Getattr($9,"name");
+			 name = Getattr($9,k_name);
 			 cname = Copy(name);
 			 Setattr($$,"tdname",cname);
 			 Delete(cname);
@@ -3163,7 +3164,7 @@ cpp_class_decl  :
 			 if (!Getattr(classes,name)) {
 			   Setattr(classes,name,$$);
 			 }
-			 Setattr($$,"decl",decltype);
+			 Setattr($$,k_decl,decltype);
 		       }
 		     }
 		   }
@@ -3174,20 +3175,20 @@ cpp_class_decl  :
 		 /* we 'open' the class at the end, to allow %template
 		    to add new members */
 		   Node *pa = new_node("access");
-		   Setattr(pa,"kind","public");
+		   Setattr(pa,k_kind,"public");
 		   cplus_mode = CPLUS_PUBLIC;
 		   appendChild($$,pa);
 		   Delete(pa);
 		 }
 
-		 Setattr($$,"symtab",Swig_symbol_popscope());
+		 Setattr($$,k_symtab,Swig_symbol_popscope());
 
 		 Classprefix = 0;
 		 if (nscope_inner) {
 		   /* this is tricky */
 		   /* we add the declaration in the original namespace */
 		   appendChild(nscope_inner,$$);
-		   Swig_symbol_setscope(Getattr(nscope_inner,"symtab"));
+		   Swig_symbol_setscope(Getattr(nscope_inner,k_symtab));
 		   Delete(Namespaceprefix);
 		   Namespaceprefix = Swig_symbol_qualifiedscopename(0);
 		   add_symbols($$);
@@ -3236,30 +3237,30 @@ cpp_class_decl  :
 	       $$ = new_node("class");
 	       unnamed = make_unnamed();
 	       Setline($$,cparse_start_line);
-	       Setattr($$,"kind",$2);
-	       Setattr($$,"storage",$1);
-	       Setattr($$,"unnamed",unnamed);
+	       Setattr($$,k_kind,$2);
+	       Setattr($$,k_storage,$1);
+	       Setattr($$,k_unnamed,unnamed);
 	       Setattr($$,"allows_typedef","1");
 
 	       /* Check for pure-abstract class */
-	       Setattr($$,"abstract", pure_abstract($5));
+	       Setattr($$,k_abstract, pure_abstract($5));
 
 	       n = new_node("cdecl");
-	       Setattr(n,"name",$7.id);
-	       Setattr(n,"unnamed",unnamed);
-	       Setattr(n,"type",unnamed);
-	       Setattr(n,"decl",$7.type);
-	       Setattr(n,"parms",$7.parms);
-	       Setattr(n,"storage",$1);
+	       Setattr(n,k_name,$7.id);
+	       Setattr(n,k_unnamed,unnamed);
+	       Setattr(n,k_type,unnamed);
+	       Setattr(n,k_decl,$7.type);
+	       Setattr(n,k_parms,$7.parms);
+	       Setattr(n,k_storage,$1);
 	       if ($8) {
 		 Node *p = $8;
 		 set_nextSibling(n,p);
 		 while (p) {
 		   String *type = Copy(unnamed);
-		   Setattr(p,"unnamed",unnamed);
-		   Setattr(p,"type",type);
+		   Setattr(p,k_unnamed,unnamed);
+		   Setattr(p,k_type,type);
 		   Delete(type);
-		   Setattr(p,"storage",$1);
+		   Setattr(p,k_storage,$1);
 		   p = nextSibling(p);
 		 }
 	       }
@@ -3273,7 +3274,7 @@ cpp_class_decl  :
 		     String *scpname = 0;
 		     name = $7.id;
 		     Setattr($$,"tdname",name);
-		     Setattr($$,"name",name);
+		     Setattr($$,k_name,name);
 		     Swig_symbol_setscopename(name);
 
 		     /* If a proper name given, we use that as the typedef, not unnamed */
@@ -3307,7 +3308,7 @@ cpp_class_decl  :
 		 appendChild($$,dump_nested(Char(name)));
 	       }
 	       /* Pop the scope */
-	       Setattr($$,"symtab",Swig_symbol_popscope());
+	       Setattr($$,k_symtab,Swig_symbol_popscope());
 	       if (class_rename) {
 		 Delete(yyrename);
 		 yyrename = NewString(class_rename);
@@ -3323,9 +3324,9 @@ cpp_class_decl  :
 cpp_opt_declarators :  SEMI { $$ = 0; }
                     |  declarator c_decl_tail {
                         $$ = new_node("cdecl");
-                        Setattr($$,"name",$1.id);
-                        Setattr($$,"decl",$1.type);
-                        Setattr($$,"parms",$1.parms);
+                        Setattr($$,k_name,$1.id);
+                        Setattr($$,k_decl,$1.type);
+                        Setattr($$,k_parms,$1.parms);
 			set_nextSibling($$,$2);
                     }
                     ;
@@ -3341,9 +3342,9 @@ cpp_forward_class_decl : storage_class cpptype idcolon SEMI {
 		$$ = new_node("classforward");
 		Setfile($$,cparse_file);
 		Setline($$,cparse_line);
-		Setattr($$,"kind",$2);
-		Setattr($$,"name",$3);
-		Setattr($$,"sym:weak", "1");
+		Setattr($$,k_kind,$2);
+		Setattr($$,k_name,$3);
+		Setattr($$,k_symweak, "1");
 		add_symbols($$);
 	      }
              }
@@ -3364,7 +3365,7 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 		      Node *ni = ntop;
 		      SwigType *ntype = ni ? nodeType(ni) : 0;
 		      while (ni && Strcmp(ntype,"namespace") == 0) {
-			sti = Getattr(ni,"symtab");
+			sti = Getattr(ni,k_symtab);
 			ni = firstChild(ni);
 			ntype = nodeType(ni);
 		      }
@@ -3377,7 +3378,7 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 
                       template_parameters = 0;
                       $$ = $6;
-		      if ($$) tname = Getattr($$,"name");
+		      if ($$) tname = Getattr($$,k_name);
 		      
 		      /* Check if the class is a template specialization */
 		      if (($$) && (Strstr(tname,"<")) && (!is_operator(tname))) {
@@ -3396,7 +3397,7 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			  Delete(tbase);
 			}
 			Setattr($$,"specialization","1");
-			Setattr($$,"templatetype",nodeType($$));
+			Setattr($$,k_templatetype,nodeType($$));
 			set_nodeType($$,"template");
 			/* Template partial specialization */
 			if (tempn && ($3) && ($6)) {
@@ -3404,12 +3405,12 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			  String *targs = SwigType_templateargs(tname);
 			  tlist = SwigType_parmlist(targs);
 			  /*			  Printf(stdout,"targs = '%s' %s\n", targs, tlist); */
-			  if (!Getattr($$,"sym:weak")) {
-			    Setattr($$,"sym:typename","1");
+			  if (!Getattr($$,k_symweak)) {
+			    Setattr($$,k_symtypename,"1");
 			  }
 			  
-			  if (Len(tlist) != ParmList_len(Getattr(tempn,"templateparms"))) {
-			    Swig_error(Getfile($$),Getline($$),"Inconsistent argument count in template partial specialization. %d %d\n", Len(tlist), ParmList_len(Getattr(tempn,"templateparms")));
+			  if (Len(tlist) != ParmList_len(Getattr(tempn,k_templateparms))) {
+			    Swig_error(Getfile($$),Getline($$),"Inconsistent argument count in template partial specialization. %d %d\n", Len(tlist), ParmList_len(Getattr(tempn,k_templateparms)));
 			    
 			  } else {
 
@@ -3435,20 +3436,20 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			    String *pn;
 			    Parm *p, *p1;
 			    int i, nargs;
-			    Parm *tp = CopyParmList(Getattr(tempn,"templateparms"));
+			    Parm *tp = CopyParmList(Getattr(tempn,k_templateparms));
 			    nargs = Len(tlist);
 			    p = $3;
 			    while (p) {
 			      for (i = 0; i < nargs; i++){
-				pn = Getattr(p,"name");
+				pn = Getattr(p,k_name);
 				if (Strcmp(pn,SwigType_base(Getitem(tlist,i))) == 0) {
 				  int j;
 				  Parm *p1 = tp;
 				  for (j = 0; j < i; j++) {
 				    p1 = nextSibling(p1);
 				  }
-				  Setattr(p1,"name",pn);
-				  Setattr(p1,"partialarg","1");
+				  Setattr(p1,k_name,pn);
+				  Setattr(p1,k_partialarg,"1");
 				}
 			      }
 			      p = nextSibling(p);
@@ -3456,37 +3457,37 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			    p1 = tp;
 			    i = 0;
 			    while (p1) {
-			      if (!Getattr(p1,"partialarg")) {
-				Delattr(p1,"name");
-				Setattr(p1,"type", Getitem(tlist,i));
+			      if (!Getattr(p1,k_partialarg)) {
+				Delattr(p1,k_name);
+				Setattr(p1,k_type, Getitem(tlist,i));
 			      } 
 			      i++;
 			      p1 = nextSibling(p1);
 			    }
-			    Setattr($$,"templateparms",tp);
+			    Setattr($$,k_templateparms,tp);
 			    Delete(tp);
 			  }
 #if 0
 			  /* Patch the parameter list */
 			  if (tempn) {
 			    Parm *p,*p1;
-			    ParmList *tp = CopyParmList(Getattr(tempn,"templateparms"));
+			    ParmList *tp = CopyParmList(Getattr(tempn,k_templateparms));
 			    p = $3;
 			    p1 = tp;
 			    while (p && p1) {
-			      String *pn = Getattr(p,"name");
+			      String *pn = Getattr(p,k_name);
 			      Printf(stdout,"pn = '%s'\n", pn);
-			      if (pn) Setattr(p1,"name",pn);
-			      else Delattr(p1,"name");
-			      pn = Getattr(p,"type");
-			      if (pn) Setattr(p1,"type",pn);
+			      if (pn) Setattr(p1,k_name,pn);
+			      else Delattr(p1,k_name);
+			      pn = Getattr(p,k_type);
+			      if (pn) Setattr(p1,k_type,pn);
 			      p = nextSibling(p);
 			      p1 = nextSibling(p1);
 			    }
-			    Setattr($$,"templateparms",tp);
+			    Setattr($$,k_templateparms,tp);
 			    Delete(tp);
 			  } else {
-			    Setattr($$,"templateparms",$3);
+			    Setattr($$,k_templateparms,$3);
 			  }
 #endif
 			  Delattr($$,"specialization");
@@ -3494,13 +3495,13 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			  /* Create a specialized name for matching */
 			  {
 			    Parm *p = $3;
-			    String *fname = NewString(Getattr($$,"name"));
+			    String *fname = NewString(Getattr($$,k_name));
 			    String *ffname = 0;
 
 			    char   tmp[32];
 			    int    i, ilen;
 			    while (p) {
-			      String *n = Getattr(p,"name");
+			      String *n = Getattr(p,k_name);
 			      if (!n) {
 				p = nextSibling(p);
 				continue;
@@ -3533,16 +3534,16 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			      Append(ffname,")>");
 			    }
 			    {
-			      String *partials = Getattr(tempn,"partials");
+			      String *partials = Getattr(tempn,k_partials);
 			      if (!partials) {
 				partials = NewList();
-				Setattr(tempn,"partials",partials);
+				Setattr(tempn,k_partials,partials);
 				Delete(partials);
 			      }
 			      /*			      Printf(stdout,"partial: fname = '%s', '%s'\n", fname, Swig_symbol_typedef_reduce(fname,0)); */
 			      Append(partials,ffname);
 			    }
-			    Setattr($$,"partialargs",ffname);
+			    Setattr($$,k_partialargs,ffname);
 			    Swig_symbol_cadd(ffname,$$);
 			  }
 			  }
@@ -3558,22 +3559,22 @@ cpp_template_decl : TEMPLATE LESSTHAN template_parms GREATERTHAN { template_para
 			  Delete(fname);
 			}
 		      }  else if ($$) {
-			Setattr($$,"templatetype",nodeType($6));
+			Setattr($$,k_templatetype,nodeType($6));
 			set_nodeType($$,"template");
-			Setattr($$,"templateparms", $3);
-			if (!Getattr($$,"sym:weak")) {
-			  Setattr($$,"sym:typename","1");
+			Setattr($$,k_templateparms, $3);
+			if (!Getattr($$,k_symweak)) {
+			  Setattr($$,k_symtypename,"1");
 			}
 			add_symbols($$);
                         default_arguments($$);
 			/* We also place a fully parameterized version in the symbol table */
 			{
 			  Parm *p;
-			  String *fname = NewStringf("%s<(", Getattr($$,"name"));
+			  String *fname = NewStringf("%s<(", Getattr($$,k_name));
 			  p = $3;
 			  while (p) {
-			    String *n = Getattr(p,"name");
-			    if (!n) n = Getattr(p,"type");
+			    String *n = Getattr(p,k_name);
+			    if (!n) n = Getattr(p,k_type);
 			    Append(fname,n);
 			    p = nextSibling(p);
 			    if (p) Putc(',',fname);
@@ -3620,17 +3621,17 @@ template_parms  : rawparms {
 		  $$ = $1;
 
 		  while (p) {
-		    String *name = Getattr(p,"name");
+		    String *name = Getattr(p,k_name);
 		    if (!name) {
 		      /* Hmmm. Maybe it's a 'class T' parameter */
-		      char *type = Char(Getattr(p,"type"));
+		      char *type = Char(Getattr(p,k_type));
 		      /* Template template parameter */
 		      if (strncmp(type,"template<class> ",16) == 0) {
 			type += 16;
 		      }
 		      if ((strncmp(type,"class ",6) == 0) || (strncmp(type,"typename ", 9) == 0)) {
 			char *t = strchr(type,' ');
-			Setattr(p,"name", t+1);
+			Setattr(p,k_name, t+1);
 		      } else {
 			/*
 			 Swig_error(cparse_file, cparse_line, "Missing template parameter name\n");
@@ -3650,8 +3651,8 @@ cpp_using_decl : USING idcolon SEMI {
                   String *uname = Swig_symbol_type_qualify($2,0);
 		  String *name = Swig_scopename_last($2);
                   $$ = new_node("using");
-		  Setattr($$,"uname",uname);
-		  Setattr($$,"name", name);
+		  Setattr($$,k_uname,uname);
+		  Setattr($$,k_name, name);
 		  Delete(uname);
 		  Delete(name);
 		  add_symbols($$);
@@ -3670,8 +3671,8 @@ cpp_using_decl : USING idcolon SEMI {
 		   if (Strcmp(nodeType(n),"namespace") == 0) {
 		     $$ = new_node("using");
 		     Setattr($$,"node",n);
-		     Setattr($$,"namespace", $3);
-		     Swig_symbol_inherit(Getattr(n,"symtab"));
+		     Setattr($$,k_namespace, $3);
+		     Swig_symbol_inherit(Getattr(n,k_symtab));
 		   } else {
 		     Swig_error(cparse_file, cparse_line, "'%s' is not a namespace.\n", $3);
 		     $$ = 0;
@@ -3688,13 +3689,13 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
                 $1 = Swig_symbol_current();
 		h = Swig_symbol_clookup($2,0);
 		if (h && (Strcmp(nodeType(h),"namespace") == 0)) {
-		  if (Getattr(h,"alias")) {
-		    h = Getattr(h,"namespace");
+		  if (Getattr(h,k_alias)) {
+		    h = Getattr(h,k_namespace);
 		    Swig_warning(WARN_PARSE_NAMESPACE_ALIAS, cparse_file, cparse_line, "Namespace alias '%s' not allowed here. Assuming '%s'\n",
-				 $2, Getattr(h,"name"));
-		    $2 = Getattr(h,"name");
+				 $2, Getattr(h,k_name));
+		    $2 = Getattr(h,k_name);
 		  }
-		  Swig_symbol_setscope(Getattr(h,"symtab"));
+		  Swig_symbol_setscope(Getattr(h,k_symtab));
 		} else {
 		  Swig_symbol_newscope();
 		  Swig_symbol_setscopename($2);
@@ -3704,8 +3705,8 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
              } interface RBRACE {
                 Node *n = $5;
 		set_nodeType(n,"namespace");
-		Setattr(n,"name",$2);
-                Setattr(n,"symtab", Swig_symbol_popscope());
+		Setattr(n,k_name,$2);
+                Setattr(n,k_symtab, Swig_symbol_popscope());
 		Swig_symbol_setscope($1);
 		$$ = n;
 		Delete(Namespaceprefix);
@@ -3717,7 +3718,7 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
 	       $1 = Swig_symbol_current();
 	       h = Swig_symbol_clookup((char *)"    ",0);
 	       if (h && (Strcmp(nodeType(h),"namespace") == 0)) {
-		 Swig_symbol_setscope(Getattr(h,"symtab"));
+		 Swig_symbol_setscope(Getattr(h,k_symtab));
 	       } else {
 		 Swig_symbol_newscope();
 		 /* we don't use "__unnamed__", but a long 'empty' name */
@@ -3727,8 +3728,8 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
              } interface RBRACE {
 	       $$ = $4;
 	       set_nodeType($$,"namespace");
-	       Setattr($$,"unnamed","1");
-	       Setattr($$,"symtab", Swig_symbol_popscope());
+	       Setattr($$,k_unnamed,"1");
+	       Setattr($$,k_symtab, Swig_symbol_popscope());
 	       Swig_symbol_setscope($1);
 	       Delete(Namespaceprefix);
 	       Namespaceprefix = Swig_symbol_qualifiedscopename(0);
@@ -3738,8 +3739,8 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
 	       /* Namespace alias */
 	       Node *n;
 	       $$ = new_node("namespace");
-	       Setattr($$,"name",$2);
-	       Setattr($$,"alias",$4);
+	       Setattr($$,k_name,$2);
+	       Setattr($$,k_alias,$4);
 	       n = Swig_symbol_clookup($4,0);
 	       if (!n) {
 		 Swig_error(cparse_file, cparse_line, "Unknown namespace '%s'\n", $4);
@@ -3749,13 +3750,13 @@ cpp_namespace_decl : NAMESPACE idcolon LBRACE {
 		   Swig_error(cparse_file, cparse_line, "'%s' is not a namespace\n",$4);
 		   $$ = 0;
 		 } else {
-		   while (Getattr(n,"alias")) {
-		     n = Getattr(n,"namespace");
+		   while (Getattr(n,k_alias)) {
+		     n = Getattr(n,k_namespace);
 		   }
-		   Setattr($$,"namespace",n);
+		   Setattr($$,k_namespace,n);
 		   add_symbols($$);
 		   /* Set up a scope alias */
-		   Swig_symbol_alias($2,Getattr(n,"symtab"));
+		   Swig_symbol_alias($2,Getattr(n,k_symtab));
 		 }
 	       }
              }
@@ -3812,11 +3813,11 @@ cpp_member   : c_declaration { $$ = $1; }
                  $$ = $1; 
 		 if (extendmode) {
 		   String *symname;
-		   symname= make_name($$,Getattr($$,"name"), Getattr($$,"decl"));
-		   if (Strcmp(symname,Getattr($$,"name")) == 0) {
+		   symname= make_name($$,Getattr($$,k_name), Getattr($$,k_decl));
+		   if (Strcmp(symname,Getattr($$,k_name)) == 0) {
 		     /* No renaming operation.  Set name to class name */
 		     Delete(yyrename);
-		     yyrename = NewString(Getattr(current_class,"sym:name"));
+		     yyrename = NewString(Getattr(current_class,k_symname));
 		   } else {
 		     Delete(yyrename);
 		     yyrename = symname;
@@ -3853,16 +3854,16 @@ cpp_constructor_decl : storage_class type LPAREN parms RPAREN ctor_end {
               if (Classprefix) {
 		 SwigType *decl = NewStringEmpty();
 		 $$ = new_node("constructor");
-		 Setattr($$,"storage",$1);
-		 Setattr($$,"name",$2);
-		 Setattr($$,"parms",$4);
+		 Setattr($$,k_storage,$1);
+		 Setattr($$,k_name,$2);
+		 Setattr($$,k_parms,$4);
 		 SwigType_add_function(decl,$4);
-		 Setattr($$,"decl",decl);
-		 Setattr($$,"throws",$6.throws);
-		 Setattr($$,"throw",$6.throwf);
+		 Setattr($$,k_decl,decl);
+		 Setattr($$,k_throws,$6.throws);
+		 Setattr($$,k_throw,$6.throwf);
 		 if (Len(scanner_ccode)) {
 		   String *code = Copy(scanner_ccode);
-		   Setattr($$,"code",code);
+		   Setattr($$,k_code,code);
 		   Delete(code);
 		 }
 		 SetFlag($$,"feature:new");
@@ -3878,21 +3879,21 @@ cpp_destructor_decl : NOT idtemplate LPAREN parms RPAREN cpp_end {
                String *name = NewStringf("%s",$2);
 	       if (*(Char(name)) != '~') Insert(name,0,"~");
                $$ = new_node("destructor");
-	       Setattr($$,"name",name);
+	       Setattr($$,k_name,name);
 	       Delete(name);
 	       if (Len(scanner_ccode)) {
 		 String *code = Copy(scanner_ccode);
-		 Setattr($$,"code",code);
+		 Setattr($$,k_code,code);
 		 Delete(code);
 	       }
 	       {
 		 String *decl = NewStringEmpty();
 		 SwigType_add_function(decl,$4);
-		 Setattr($$,"decl",decl);
+		 Setattr($$,k_decl,decl);
 		 Delete(decl);
 	       }
-	       Setattr($$,"throws",$6.throws);
-	       Setattr($$,"throw",$6.throwf);
+	       Setattr($$,k_throws,$6.throws);
+	       Setattr($$,k_throw,$6.throwf);
 	       add_symbols($$);
 	      }
 
@@ -3910,25 +3911,25 @@ cpp_destructor_decl : NOT idtemplate LPAREN parms RPAREN cpp_end {
 		    $3 = NewStringf("%s%s",$3,c);
 		  }
 		}
-		Setattr($$,"storage","virtual");
+		Setattr($$,k_storage,"virtual");
 	        name = NewStringf("%s",$3);
 		if (*(Char(name)) != '~') Insert(name,0,"~");
-		Setattr($$,"name",name);
+		Setattr($$,k_name,name);
 		Delete(name);
-		Setattr($$,"throws",$7.throws);
-		Setattr($$,"throw",$7.throwf);
+		Setattr($$,k_throws,$7.throws);
+		Setattr($$,k_throw,$7.throwf);
 		if ($7.val) {
-		  Setattr($$,"value","0");
+		  Setattr($$,k_value,"0");
 		}
 		if (Len(scanner_ccode)) {
 		  String *code = Copy(scanner_ccode);
-		  Setattr($$,"code",code);
+		  Setattr($$,k_code,code);
 		  Delete(code);
 		}
 		{
 		  String *decl = NewStringEmpty();
 		  SwigType_add_function(decl,$5);
-		  Setattr($$,"decl",decl);
+		  Setattr($$,k_decl,decl);
 		  Delete(decl);
 		}
 
@@ -3940,47 +3941,47 @@ cpp_destructor_decl : NOT idtemplate LPAREN parms RPAREN cpp_end {
 /* C++ type conversion operator */
 cpp_conversion_operator : storage_class COPERATOR type pointer LPAREN parms RPAREN cpp_vend {
                  $$ = new_node("cdecl");
-                 Setattr($$,"type",$3);
-		 Setattr($$,"name",$2);
+                 Setattr($$,k_type,$3);
+		 Setattr($$,k_name,$2);
 
 		 SwigType_add_function($4,$6);
 		 if ($8.qualifier) {
 		   SwigType_push($4,$8.qualifier);
 		 }
-		 Setattr($$,"decl",$4);
-		 Setattr($$,"parms",$6);
-		 Setattr($$,"conversion_operator","1");
+		 Setattr($$,k_decl,$4);
+		 Setattr($$,k_parms,$6);
+		 Setattr($$,k_conversionoperator,"1");
 		 add_symbols($$);
               }
                | storage_class COPERATOR type AND LPAREN parms RPAREN cpp_vend {
 		 SwigType *decl;
                  $$ = new_node("cdecl");
-                 Setattr($$,"type",$3);
-		 Setattr($$,"name",$2);
+                 Setattr($$,k_type,$3);
+		 Setattr($$,k_name,$2);
 		 decl = NewStringEmpty();
 		 SwigType_add_reference(decl);
 		 SwigType_add_function(decl,$6);
 		 if ($8.qualifier) {
 		   SwigType_push(decl,$8.qualifier);
 		 }
-		 Setattr($$,"decl",decl);
-		 Setattr($$,"parms",$6);
-		 Setattr($$,"conversion_operator","1");
+		 Setattr($$,k_decl,decl);
+		 Setattr($$,k_parms,$6);
+		 Setattr($$,k_conversionoperator,"1");
 		 add_symbols($$);
 	       }
 
               | storage_class COPERATOR type LPAREN parms RPAREN cpp_vend {
 		String *t = NewStringEmpty();
 		$$ = new_node("cdecl");
-		Setattr($$,"type",$3);
-		Setattr($$,"name",$2);
+		Setattr($$,k_type,$3);
+		Setattr($$,k_name,$2);
 		SwigType_add_function(t,$5);
 		if ($7.qualifier) {
 		  SwigType_push(t,$7.qualifier);
 		}
-		Setattr($$,"decl",t);
-		Setattr($$,"parms",$5);
-		Setattr($$,"conversion_operator","1");
+		Setattr($$,k_decl,t);
+		Setattr($$,k_parms,$5);
+		Setattr($$,k_conversionoperator,"1");
 		add_symbols($$);
               }
               ;
@@ -3996,14 +3997,14 @@ cpp_catch_decl : CATCH LPAREN parms RPAREN LBRACE {
 /* public: */
 cpp_protection_decl : PUBLIC COLON { 
                 $$ = new_node("access");
-		Setattr($$,"kind","public");
+		Setattr($$,k_kind,"public");
                 cplus_mode = CPLUS_PUBLIC;
               }
 
 /* private: */
               | PRIVATE COLON { 
                 $$ = new_node("access");
-                Setattr($$,"kind","private");
+                Setattr($$,k_kind,"private");
 		cplus_mode = CPLUS_PRIVATE;
 	      }
 
@@ -4011,7 +4012,7 @@ cpp_protection_decl : PUBLIC COLON {
 
               | PROTECTED COLON { 
 		$$ = new_node("access");
-		Setattr($$,"kind","protected");
+		Setattr($$,k_kind,"protected");
 		cplus_mode = CPLUS_PROTECTED;
 	      }
               ;
@@ -4208,7 +4209,7 @@ parms          : rawparms {
 		 $$ = $1;
 		 p = $1;
                  while (p) {
-		   Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
+		   Replace(Getattr(p,k_type),"typename ", "", DOH_REPLACE_ANY);
 		   p = nextSibling(p);
                  }
                }
@@ -4239,7 +4240,7 @@ parm           : rawtype parameter_declarator {
 		   Setfile($$,cparse_file);
 		   Setline($$,cparse_line);
 		   if ($2.defarg) {
-		     Setattr($$,"value",$2.defarg);
+		     Setattr($$,k_value,$2.defarg);
 		   }
 		}
 
@@ -4261,8 +4262,8 @@ valparms        : rawvalparms {
 		 $$ = $1;
 		 p = $1;
                  while (p) {
-		   if (Getattr(p,"type")) {
-		     Replace(Getattr(p,"type"),"typename ", "", DOH_REPLACE_ANY);
+		   if (Getattr(p,k_type)) {
+		     Replace(Getattr(p,k_type),"typename ", "", DOH_REPLACE_ANY);
 		   }
 		   p = nextSibling(p);
                  }
@@ -4296,15 +4297,15 @@ valparm        : parm {
 		    Node     *n = 0;
 
 		    while (!n) {
-		      type = Getattr($1,"type");
+		      type = Getattr($1,k_type);
 		      n = Swig_symbol_clookup(type,0);     /* See if we can find a node that matches the typename */
 		      if ((n) && (Strcmp(nodeType(n),"cdecl") == 0)) {
-			SwigType *decl = Getattr(n,"decl");
+			SwigType *decl = Getattr(n,k_decl);
 			if (!SwigType_isfunction(decl)) {
-			  String *value = Getattr(n,"value");
+			  String *value = Getattr(n,k_value);
 			  if (value) {
 			    String *v = Copy(value);
-			    Setattr($1,"type",v);
+			    Setattr($1,k_type,v);
 			    Delete(v);
 			    n = 0;
 			  }
@@ -4320,14 +4321,14 @@ valparm        : parm {
                   $$ = NewParm(0,0);
                   Setfile($$,cparse_file);
 		  Setline($$,cparse_line);
-		  Setattr($$,"value",$1.val);
+		  Setattr($$,k_value,$1.val);
                }
                | STRING {
 		  String *v = NewString($1);
                   $$ = NewParm(0,0);
                   Setfile($$,cparse_file);
 		  Setline($$,cparse_line);
-		  Setattr($$,"value",v);
+		  Setattr($$,k_value,v);
 		  Delete(v);
                }
                ;
@@ -5124,24 +5125,24 @@ enumlist       :  enumlist COMMA edecl {
 edecl          :  ID {
 		   SwigType *type = NewSwigType(T_INT);
 		   $$ = new_node("enumitem");
-		   Setattr($$,"name",$1);
-		   Setattr($$,"type",type);
+		   Setattr($$,k_name,$1);
+		   Setattr($$,k_type,type);
 		   SetFlag($$,"feature:immutable");
 		   Delete(type);
 		 }
                  | ID EQUAL etype {
 		   $$ = new_node("enumitem");
-		   Setattr($$,"name",$1);
+		   Setattr($$,k_name,$1);
 		   Setattr($$,"enumvalue", $3.val);
 	           if ($3.type == T_CHAR) {
 		     SwigType *type = NewSwigType(T_CHAR);
-		     Setattr($$,"value",$3.val);
-		     Setattr($$,"type",type);
+		     Setattr($$,k_value,$3.val);
+		     Setattr($$,k_type,type);
 		     Delete(type);
 		   } else {
 		     SwigType *type = NewSwigType(T_INT);
-		     Setattr($$,"value",$1);
-		     Setattr($$,"type",type);
+		     Setattr($$,k_value,$1);
+		     Setattr($$,k_type,type);
 		     Delete(type);
 		   }
 		   SetFlag($$,"feature:immutable");
@@ -5191,7 +5192,7 @@ expr           :  exprnum { $$ = $1; }
                    if (Strcmp(nodeType(n),"enumitem") == 0) {
                      String *q = Swig_symbol_qualified(n);
                      if (q) {
-                       $$.val = NewStringf("%s::%s", q, Getattr(n,"name"));
+                       $$.val = NewStringf("%s::%s", q, Getattr(n,k_name));
                        Delete(q);
                      }
                    }
@@ -5341,7 +5342,7 @@ raw_inherit     : COLON { inherit_list = 1; } base_list { $$ = $3; inherit_list
 base_list      : base_specifier {
 		   Hash *list = NewHash();
 		   Node *base = $1;
-		   Node *name = Getattr(base,"name");
+		   Node *name = Getattr(base,k_name);
 		   List *lpublic = NewList();
 		   List *lprotected = NewList();
 		   List *lprivate = NewList();
@@ -5351,15 +5352,15 @@ base_list      : base_specifier {
 		   Delete(lpublic);
 		   Delete(lprotected);
 		   Delete(lprivate);
-		   Append(Getattr(list,Getattr(base,"access")),name);
+		   Append(Getattr(list,Getattr(base,k_access)),name);
 	           $$ = list;
                }
 
                | base_list COMMA base_specifier {
 		   Hash *list = $1;
 		   Node *base = $3;
-		   Node *name = Getattr(base,"name");
-		   Append(Getattr(list,Getattr(base,"access")),name);
+		   Node *name = Getattr(base,k_name);
+		   Append(Getattr(list,Getattr(base,k_access)),name);
                    $$ = list;
                }
                ;
@@ -5368,21 +5369,21 @@ base_specifier : opt_virtual idcolon {
 		 $$ = NewHash();
 		 Setfile($$,cparse_file);
 		 Setline($$,cparse_line);
-		 Setattr($$,"name",$2);
+		 Setattr($$,k_name,$2);
                  if (last_cpptype && (Strcmp(last_cpptype,"struct") != 0)) {
-		   Setattr($$,"access","private");
+		   Setattr($$,k_access,"private");
 		   Swig_warning(WARN_PARSE_NO_ACCESS,cparse_file,cparse_line,
 				"No access specifier given for base class %s (ignored).\n",$2);
                  } else {
-		   Setattr($$,"access","public");
+		   Setattr($$,k_access,"public");
 		 }
                }
 	       | opt_virtual access_specifier opt_virtual idcolon {
 		 $$ = NewHash();
 		 Setfile($$,cparse_file);
 		 Setline($$,cparse_line);
-		 Setattr($$,"name",$4);
-		 Setattr($$,"access",$2);
+		 Setattr($$,k_name,$4);
+		 Setattr($$,k_access,$2);
 	         if (Strcmp($2,"public") != 0) {
 		   Swig_warning(WARN_PARSE_PRIVATE_INHERIT, cparse_file, 
 				cparse_line,"%s inheritance ignored.\n", $2);
@@ -5626,8 +5627,8 @@ options        : LPAREN kwargs RPAREN {
                   n = $2;
                   while(n) {
                      String *name, *value;
-                     name = Getattr(n,"name");
-                     value = Getattr(n,"value");
+                     name = Getattr(n,k_name);
+                     value = Getattr(n,k_value);
 		     if (!value) value = (String *) "1";
                      Setattr($$,name, value);
 		     n = nextSibling(n);
@@ -5639,31 +5640,31 @@ options        : LPAREN kwargs RPAREN {
 /* Keyword arguments */
 kwargs         : idstring EQUAL stringnum {
 		 $$ = NewHash();
-		 Setattr($$,"name",$1);
-		 Setattr($$,"value",$3);
+		 Setattr($$,k_name,$1);
+		 Setattr($$,k_value,$3);
                }
                | idstring EQUAL stringnum COMMA kwargs {
 		 $$ = NewHash();
-		 Setattr($$,"name",$1);
-		 Setattr($$,"value",$3);
+		 Setattr($$,k_name,$1);
+		 Setattr($$,k_value,$3);
 		 set_nextSibling($$,$5);
                }
                | idstring {
                  $$ = NewHash();
-                 Setattr($$,"name",$1);
+                 Setattr($$,k_name,$1);
 	       }
                | idstring COMMA kwargs {
                  $$ = NewHash();
-                 Setattr($$,"name",$1);
+                 Setattr($$,k_name,$1);
                  set_nextSibling($$,$3);
                }
                | idstring EQUAL stringtype  {
                  $$ = $3;
-		 Setattr($$,"name",$1);
+		 Setattr($$,k_name,$1);
                }
                | idstring EQUAL stringtype COMMA kwargs {
                  $$ = $3;
-		 Setattr($$,"name",$1);
+		 Setattr($$,k_name,$1);
 		 set_nextSibling($$,$5);
                }
                ;
diff --git a/Source/CParse/util.c b/Source/CParse/util.c
index 0bd9b5999..a4daa7542 100644
--- a/Source/CParse/util.c
+++ b/Source/CParse/util.c
@@ -12,6 +12,7 @@
 char cvsroot_util_c[] = "$Header$";
 
 #include "swig.h"
+#include "swigkeys.h"
 #include "cparse.h"
 
 /* -----------------------------------------------------------------------------
@@ -77,13 +78,13 @@ void Swig_cparse_replace_descriptor(String *s) {
  * ----------------------------------------------------------------------------- */
 
 void cparse_normalize_void(Node *n) {
-  String *decl = Getattr(n,"decl");
-  Parm   *parms = Getattr(n,"parms");
+  String *decl = Getattr(n,k_decl);
+  Parm   *parms = Getattr(n,k_parms);
 
   if (SwigType_isfunction(decl)) {
-    if ((ParmList_len(parms) == 1) && (SwigType_type(Getattr(parms,"type")) == T_VOID)) {
+    if ((ParmList_len(parms) == 1) && (SwigType_type(Getattr(parms,k_type)) == T_VOID)) {
       Replaceall(decl,"f(void).","f().");
-      Delattr(n,"parms");
+      Delattr(n,k_parms);
     }
   }
 }
diff --git a/Source/Swig/cwrap.c b/Source/Swig/cwrap.c
index 0dc0e5e12..c7702173c 100644
--- a/Source/Swig/cwrap.c
+++ b/Source/Swig/cwrap.c
@@ -849,7 +849,7 @@ Swig_MethodToFunction(Node *n, String *classname, int flags) {
     /* Methods with default arguments are wrapped with additional methods for each default argument,
      * however, only one extra %extend method is generated. */
 
-    String *defaultargs = Getattr(n,"defaultargs");
+    String *defaultargs = Getattr(n,k_defaultargs);
     String *code = Getattr(n,k_code);
     String *cname = Getattr(n,k_classname) ? Getattr(n,k_classname) : classname;
     String *membername = Swig_name_member(cname, name);
@@ -938,21 +938,21 @@ Swig_methodclass(Node *n) {
 int
 Swig_directorbase(Node *n) {
   Node *classNode = Swig_methodclass(n);
-  return (classNode && (Getattr(classNode, "directorBase") != 0));
+  return (classNode && (Getattr(classNode, k_directorbase) != 0));
 }
 
 int
 Swig_directorclass(Node *n) {
   Node *classNode = Swig_methodclass(n);
   assert(classNode != 0);
-  return (Getattr(classNode, "vtable") != 0);
+  return (Getattr(classNode, k_vtable) != 0);
 }
 
 int
 Swig_directormethod(Node *n) {
   Node *classNode = Swig_methodclass(n);
   if (classNode) {
-    Node *vtable = Getattr(classNode, "vtable");
+    Node *vtable = Getattr(classNode, k_vtable);
     if (vtable) {
       String *name = Getattr(n, k_name);
       String *decl = Getattr(n, k_decl);
@@ -962,7 +962,7 @@ Swig_directormethod(Node *n) {
       Delete(method_id);
       Delete(local_decl);
       if (item) {
-        return (Getattr(item, "director") != 0);
+        return (Getattr(item, k_director) != 0);
       }
     }
   }
@@ -977,7 +977,7 @@ Swig_directormap(Node *module, String *type) {
 
     String* base = SwigType_base(type);
 
-    Node *directormap = Getattr(module, "wrap:directormap");
+    Node *directormap = Getattr(module, k_wrapdirectormap);
     if (directormap)
       return Getattr(directormap, base);
   }
@@ -1009,7 +1009,7 @@ Swig_ConstructorToFunction(Node *n, String *classname,
   parms = CopyParmList(nonvoid_parms(Getattr(n,k_parms)));
 
   /* Prepend the list of prefix_args (if any) */
-  prefix_args = Getattr(n,"director:prefix_args");
+  prefix_args = Getattr(n,k_directorprefixargs);
   if (prefix_args != NIL) {
     Parm *p2, *p3;
 
@@ -1032,7 +1032,7 @@ Swig_ConstructorToFunction(Node *n, String *classname,
      * however, only one extra %extend method is generated. */
     String *call;
     String *cres;
-    String *defaultargs = Getattr(n,"defaultargs");
+    String *defaultargs = Getattr(n,k_defaultargs);
     String *code = Getattr(n,k_code);
     String *membername = Swig_name_construct(classname);
     String *mangled = Swig_name_mangle(membername);
@@ -1061,7 +1061,7 @@ Swig_ConstructorToFunction(Node *n, String *classname,
       /* if a C++ director class exists, create it rather than the original class */
       if (use_director) {
 	Node *parent = Swig_methodclass(n);
-  	int abstract = Getattr(parent, "abstract") != 0;
+  	int abstract = Getattr(parent, k_abstract) != 0;
 	String *name = Getattr(parent, k_symname);
         String* directorname = NewStringf("SwigDirector_%s", name);
 	String* action = NewStringEmpty();
@@ -1295,7 +1295,7 @@ Swig_MembergetToFunction(Node *n, String *classname, int flags) {
 
   if (flags & CWRAP_SMART_POINTER) {
     if (checkAttribute(n, k_storage, k_static)) {
-      Node *sn = Getattr(n,"cplus:staticbase");
+      Node *sn = Getattr(n,k_cplusstaticbase);
       String *base = Getattr(sn,k_name); 
       self = NewStringf("%s::", base);
     } else {
diff --git a/Source/Swig/fragment.c b/Source/Swig/fragment.c
index e8145b5f3..2793a5915 100644
--- a/Source/Swig/fragment.c
+++ b/Source/Swig/fragment.c
@@ -17,6 +17,7 @@
 char cvsroot_fragment_c[] = "$Header$";
 
 #include "swig.h"
+#include "swigkeys.h"
 
 static Hash *fragments = 0;
 static Hash *looking_fragments = 0;
@@ -32,12 +33,12 @@ static int debug = 0;
 
 void
 Swig_fragment_register(Node* fragment) {
-  if (Getattr(fragment,"emitonly")) {
+  if (Getattr(fragment,k_emitonly)) {
     Swig_fragment_emit(fragment);
     return;
   } else {
-    String *name = Copy(Getattr(fragment,"value"));
-    String *type = Getattr(fragment,"type");
+    String *name = Copy(Getattr(fragment,k_value));
+    String *type = Getattr(fragment,k_type);
     if (type) {
       SwigType *rtype = SwigType_typedef_resolve_all(type);
       String *mangle = Swig_string_mangle(type);
@@ -50,12 +51,12 @@ Swig_fragment_register(Node* fragment) {
       fragments = NewHash();
     }
     if (!Getattr(fragments,name)) {
-      String *section = Copy(Getattr(fragment,"section"));
-      String *ccode = Copy(Getattr(fragment,"code"));
-      Hash *kwargs = Getattr(fragment,"kwargs");
-      Setmeta(ccode,"section",section);
+      String *section = Copy(Getattr(fragment,k_section));
+      String *ccode = Copy(Getattr(fragment,k_code));
+      Hash *kwargs = Getattr(fragment,k_kwargs);
+      Setmeta(ccode,k_section,section);
       if (kwargs) {
-	Setmeta(ccode,"kwargs",kwargs);
+	Setmeta(ccode,k_kwargs,kwargs);
       }
       Setattr(fragments,name,ccode);
       if (debug) Printf(stdout,"registering fragment %s %s\n",name,section);
@@ -90,11 +91,11 @@ Swig_fragment_emit(Node *n) {
 
   if (!fragments) return;
 
-  name = Getattr(n,"value");
+  name = Getattr(n,k_value);
   if (!name) {
     name = n;
   }
-  type = Getattr(n,"type");
+  type = Getattr(n,k_type);
   if (type) {
     mangle = Swig_string_mangle(type);
   }
@@ -112,13 +113,13 @@ Swig_fragment_emit(Node *n) {
     }    
     code = Getattr(fragments,name);
     if (debug) Printf(stdout,"looking subfragment %s\n", name);
-    if (code && (Strcmp(code,"ignore") != 0)) {
-      String *section = Getmeta(code,"section");
-      Hash *n = Getmeta(code,"kwargs");
+    if (code && (Strcmp(code,k_ignore) != 0)) {
+      String *section = Getmeta(code,k_section);
+      Hash *n = Getmeta(code,k_kwargs);
       if (!looking_fragments) looking_fragments = NewHash();
       Setattr(looking_fragments,name,"1");      
       while (n) {
-	if (Cmp(Getattr(n,"name"),"fragment") == 0) {
+	if (Equal(Getattr(n,k_name),k_fragment)) {
 	  if (debug) Printf(stdout,"emitting fragment %s %s\n",n, type);
 	  Swig_fragment_emit(n);
 	}
@@ -134,7 +135,7 @@ Swig_fragment_emit(Node *n) {
 	  if (debug) Printf(f,"/* begin fragment %s */\n",name);
 	  Printf(f,"%s\n",code);
 	  if (debug) Printf(f,"/* end fragment %s */\n\n",name);
-	  Setattr(fragments,name,"ignore");
+	  Setattr(fragments,name,k_ignore);
 	  Delattr(looking_fragments,name);      
 	}
       }
@@ -142,7 +143,7 @@ Swig_fragment_emit(Node *n) {
       if (code && type) {
 	SwigType *rtype = SwigType_typedef_resolve_all(type);
 	if (!Equal(type,rtype)) {
-	  String *name = Copy(Getattr(n,"value"));
+	  String *name = Copy(Getattr(n,k_value));
 	  Append(name,rtype);
 	  Swig_fragment_emit(name);
 	  Delete(name);
diff --git a/Source/Swig/include.c b/Source/Swig/include.c
index b9ce2beac..de090e821 100644
--- a/Source/Swig/include.c
+++ b/Source/Swig/include.c
@@ -14,6 +14,7 @@
 char cvsroot_include_c[] = "$Header$";
 
 #include "swig.h"
+#include "swigkeys.h"
 
 /* Delimeter used in accessing files and directories */
 
@@ -166,7 +167,7 @@ Swig_search_path_any(int syspath) {
     filename = NewStringEmpty();
     assert(filename);
     Printf(filename, "%s%s", dirname, SWIG_FILE_DELIMETER);
-    if (syspath && !Getattr(dirname,"sysdir")) {
+    if (syspath && !Getattr(dirname,k_sysdir)) {
       Append(llist,filename);
     } else {
       Append(slist,filename);
diff --git a/Source/Swig/swigkeys.c b/Source/Swig/swigkeys.c
index 7a2db7e45..c60612603 100644
--- a/Source/Swig/swigkeys.c
+++ b/Source/Swig/swigkeys.c
@@ -3,7 +3,9 @@
 String *empty_string = 0;
 String *k_1 = 0;
 String *k_SWIGTYPE = 0;
+String *k_abstract = 0;
 String *k_access = 0;
+String *k_alias = 0;
 String *k_allowstypedef = 0;
 String *k_alttype = 0;
 String *k_argbyname = 0;
@@ -14,6 +16,7 @@ String *k_cdecl = 0;
 String *k_class = 0;
 String *k_classforward = 0;
 String *k_classname = 0;
+String *k_cplusstaticbase = 0;
 String *k_code = 0;
 String *k_coloncolon = 0;
 String *k_compactdefargs = 0;
@@ -24,12 +27,19 @@ String *k_csymnextSibling = 0;
 String *k_csympreviousSibling = 0;
 String *k_csymtab = 0;
 String *k_decl = 0;
+String *k_default = 0;
+String *k_defaultargs = 0;
 String *k_destroy = 0;
 String *k_destructor = 0;
+String *k_director = 0;
+String *k_directorbase = 0;
+String *k_directorprefixargs = 0;
 String *k_disown = 0;
+String *k_emitonly = 0;
 String *k_enumitem = 0;
 String *k_error = 0;
 String *k_extern = 0;
+String *k_fragment = 0;
 String *k_friend = 0;
 String *k_fullname = 0;
 String *k_get = 0;
@@ -39,6 +49,7 @@ String *k_inherit = 0;
 String *k_kwargs = 0;
 String *k_lname = 0;
 String *k_locals = 0;
+String *k_kind = 0;
 String *k_matchlist = 0;
 String *k_member = 0;
 String *k_name = 0;
@@ -49,6 +60,7 @@ String *k_parent = 0;
 String *k_parentnode = 0;
 String *k_parm = 0;
 String *k_parms = 0;
+String *k_partialarg = 0;
 String *k_partialargs = 0;
 String *k_partials = 0;
 String *k_pattern = 0;
@@ -60,6 +72,7 @@ String *k_qualifier = 0;
 String *k_rename = 0;
 String *k_result = 0;
 String *k_scope = 0;
+String *k_section = 0;
 String *k_self = 0;
 String *k_set = 0;
 String *k_sourcefmt = 0;
@@ -76,22 +89,28 @@ String *k_symsymtab = 0;
 String *k_symtab = 0;
 String *k_symtypename = 0;
 String *k_symweak = 0;
+String *k_sysdir = 0;
 String *k_targetfmt = 0;
 String *k_targetname = 0;
 String *k_template = 0;
 String *k_templateparm = 0;
 String *k_templateparms = 0;
 String *k_templatetype = 0;
+String *k_throw = 0;
 String *k_throws = 0;
 String *k_tmapmatch = 0;
 String *k_type = 0;
 String *k_typedef = 0;
 String *k_typetab = 0;
 String *k_uname = 0;
+String *k_unnamed = 0;
 String *k_using = 0;
 String *k_value = 0;
+String *k_view = 0;
 String *k_virtual = 0;
+String *k_vtable = 0;
 String *k_wrapaction = 0;
+String *k_wrapdirectormap = 0;
 String *k_wrapdisown = 0;
 String *k_wrapper = 0;
 
@@ -99,7 +118,9 @@ void Swig_keys_init() {
   empty_string = NewString("");
   k_1 = NewString("1");
   k_SWIGTYPE = NewString("SWIGTYPE");
+  k_abstract = NewString("abstract");
   k_access = NewString("access");
+  k_alias = NewString("alias");
   k_allowstypedef = NewString("allows_typedef");
   k_alttype = NewString("alttype");
   k_argbyname = NewString("arg:byname");
@@ -110,6 +131,7 @@ void Swig_keys_init() {
   k_class = NewString("class");
   k_classforward = NewString("classforward");
   k_classname = NewString("classname");
+  k_cplusstaticbase = NewString("cplus:staticbase");;
   k_code = NewString("code");
   k_coloncolon = NewString("::");
   k_compactdefargs = NewString("compactdefargs");
@@ -120,11 +142,18 @@ void Swig_keys_init() {
   k_csympreviousSibling = NewString("csym:previousSibling");
   k_csymtab = NewString("csymtab");
   k_decl = NewString("decl");
+  k_default = NewString("default");
+  k_defaultargs = NewString("defaultargs");
   k_destroy = NewString("destroy");
   k_destructor = NewString("destructor");
+  k_director = NewString("director");
+  k_directorbase = NewString("directorBase");
+  k_directorprefixargs = NewString("director:prefix_args");
   k_disown = NewString("disown");
+  k_emitonly = NewString("emitonly");
   k_enumitem = NewString("enumitem");
   k_error = NewString("error");
+  k_fragment = NewString("fragment");
   k_friend = NewString("friend");
   k_fullname = NewString("fullname");
   k_get = NewString("get");
@@ -134,6 +163,7 @@ void Swig_keys_init() {
   k_kwargs = NewString("kwargs");
   k_lname = NewString("lname");
   k_locals = NewString("locals");
+  k_kind = NewString("kind");
   k_matchlist = NewString("matchlist");
   k_member = NewString("member");
   k_name = NewString("name");
@@ -144,6 +174,7 @@ void Swig_keys_init() {
   k_parentnode = NewString("parentNode");
   k_parm = NewString("parm");
   k_parms = NewString("parms");
+  k_partialarg = NewString("partialarg");
   k_partialargs = NewString("partialargs");
   k_partials = NewString("partials");
   k_pattern = NewString("pattern");
@@ -155,6 +186,7 @@ void Swig_keys_init() {
   k_rename = NewString("rename");
   k_result = NewString("result");
   k_scope = NewString("scope");
+  k_section = NewString("section");
   k_self = NewString("self");
   k_set = NewString("set");
   k_sourcefmt = NewString("sourcefmt");
@@ -171,22 +203,28 @@ void Swig_keys_init() {
   k_symtab = NewString("symtab");
   k_symtypename = NewString("sym:typename");
   k_symweak = NewString("sym:weak");
+  k_sysdir = NewString("sysdir");
   k_targetfmt = NewString("targetfmt");
   k_targetname = NewString("targetname");
   k_template = NewString("template");
   k_templateparm = NewString("templateparm");
   k_templateparms = NewString("templateparms");
   k_templatetype = NewString("templatetype");
+  k_throw = NewString("throw");
   k_throws = NewString("throws");
   k_tmapmatch = NewString("tmap:match");
   k_type = NewString("type");
   k_typedef = NewString("typedef");
   k_typetab = NewString("typetab");
   k_uname = NewString("uname");
+  k_unnamed = NewString("unnamed");
   k_using = NewString("using");
   k_value = NewString("value");
+  k_view = NewString("view");
   k_virtual = NewString("virtual");
+  k_vtable = NewString("vtable");
   k_wrapaction = NewString("wrap:action");
+  k_wrapdirectormap = NewString("wrap:directormap");
   k_wrapdisown = NewString("wrap:disown");
   k_wrapper = NewString("wrapper");
 }
diff --git a/Source/Swig/swigkeys.h b/Source/Swig/swigkeys.h
index 1cf5244f2..e6646ab03 100644
--- a/Source/Swig/swigkeys.h
+++ b/Source/Swig/swigkeys.h
@@ -8,7 +8,9 @@ extern void Swig_keys_init();
 extern String *empty_string;
 extern String *k_1;
 extern String *k_SWIGTYPE;
+extern String *k_abstract;
 extern String *k_access;
+extern String *k_alias;
 extern String *k_allowstypedef;
 extern String *k_alttype;
 extern String *k_argbyname;
@@ -19,6 +21,7 @@ extern String *k_cdecl;
 extern String *k_class;
 extern String *k_classforward;
 extern String *k_classname;
+extern String *k_cplusstaticbase;
 extern String *k_code;
 extern String *k_coloncolon;
 extern String *k_compactdefargs;
@@ -29,12 +32,19 @@ extern String *k_csymnextSibling;
 extern String *k_csympreviousSibling;
 extern String *k_csymtab;
 extern String *k_decl;
+extern String *k_default;
+extern String *k_defaultargs;
 extern String *k_destroy;
 extern String *k_destructor;
+extern String *k_director;
+extern String *k_directorbase;
+extern String *k_directorprefixargs;
 extern String *k_disown;
+extern String *k_emitonly;
 extern String *k_enumitem;
 extern String *k_error;
 extern String *k_extern;
+extern String *k_fragment;
 extern String *k_friend;
 extern String *k_fullname;
 extern String *k_get;
@@ -44,6 +54,7 @@ extern String *k_inherit;
 extern String *k_kwargs;
 extern String *k_lname;
 extern String *k_locals;
+extern String *k_kind;
 extern String *k_matchlist;
 extern String *k_member;
 extern String *k_name;
@@ -54,6 +65,7 @@ extern String *k_parent;
 extern String *k_parentnode;
 extern String *k_parm;
 extern String *k_parms;
+extern String *k_partialarg;
 extern String *k_partialargs;
 extern String *k_partials;
 extern String *k_pattern;
@@ -65,6 +77,7 @@ extern String *k_qualifier;
 extern String *k_rename;
 extern String *k_result;
 extern String *k_scope;
+extern String *k_section;
 extern String *k_self;
 extern String *k_set;
 extern String *k_sourcefmt;
@@ -81,22 +94,28 @@ extern String *k_symsymtab;
 extern String *k_symtab;
 extern String *k_symtypename;
 extern String *k_symweak;
+extern String *k_sysdir;
 extern String *k_targetfmt;
 extern String *k_targetname;
 extern String *k_template;
 extern String *k_templateparm;
 extern String *k_templateparms;
 extern String *k_templatetype;
+extern String *k_throw;
 extern String *k_throws;
 extern String *k_tmapmatch;
 extern String *k_type;
 extern String *k_typedef;
 extern String *k_typetab;
 extern String *k_uname;
+extern String *k_unnamed;
 extern String *k_using;
 extern String *k_value;
 extern String *k_virtual;
+extern String *k_view;
+extern String *k_vtable;
 extern String *k_wrapaction;
+extern String *k_wrapdirectormap;
 extern String *k_wrapdisown;
 extern String *k_wrapper;
 
diff --git a/Source/Swig/tree.c b/Source/Swig/tree.c
index 4b3837d7a..e9e140fed 100644
--- a/Source/Swig/tree.c
+++ b/Source/Swig/tree.c
@@ -11,6 +11,7 @@
  * ----------------------------------------------------------------------------- */
 
 #include "swig.h"
+#include "swigkeys.h"
 #include <stdarg.h>
 #include <assert.h>
 
@@ -304,16 +305,16 @@ Swig_require(const char *ns, Node *n, ...) {
 
   /* Save the view */
   {
-    String *view = Getattr(n,"view");
+    String *view = Getattr(n,k_view);
     if (view) {
       if (Strcmp(view,ns) != 0) {
 	strcpy(temp,ns);
 	strcat(temp,":view");
 	Setattr(n,temp,view);
-	Setattr(n,"view",ns);
+	Setattr(n,k_view,ns);
       }
     } else {
-      Setattr(n,"view",ns);
+      Setattr(n,k_view,ns);
     }
   }
 
@@ -358,16 +359,16 @@ Swig_save(const char *ns, Node *n, ...) {
 
   /* Save the view */
   {
-    String *view = Getattr(n,"view");
+    String *view = Getattr(n,k_view);
     if (view) {
       if (Strcmp(view,ns) != 0) {
 	strcpy(temp,ns);
 	strcat(temp,":view");
 	Setattr(n,temp,view);
-	Setattr(n,"view",ns);
+	Setattr(n,k_view,ns);
       }
     } else {
-      Setattr(n,"view",ns);
+      Setattr(n,k_view,ns);
     }
   }
 
@@ -387,7 +388,7 @@ Swig_restore(Node *n) {
   String *ns;
   Iterator ki;
 
-  ns = Getattr(n,"view");
+  ns = Getattr(n,k_view);
   assert(ns);
 
   l = NewList();
diff --git a/Source/Swig/typeobj.c b/Source/Swig/typeobj.c
index 9790097ab..55a911f86 100644
--- a/Source/Swig/typeobj.c
+++ b/Source/Swig/typeobj.c
@@ -15,6 +15,7 @@
 char cvsroot_typeobj_c[] = "$Header$";
 
 #include "swig.h"
+#include "swigkeys.h"
 #include <ctype.h>
 
 /* -----------------------------------------------------------------------------
@@ -663,7 +664,7 @@ SwigType_add_function(SwigType *t, ParmList *parms) {
   p = parms;
   for (p = parms; p; p = nextSibling(p)) {
     if (p != parms) Putc(',',pstr);
-    Append(pstr, Getattr(p,"type"));
+    Append(pstr, Getattr(p,k_type));
   }
   Insert(t,0,pstr);
   Delete(pstr);
@@ -757,13 +758,13 @@ SwigType_add_template(SwigType *t, ParmList *parms) {
   p = parms;
   for (p = parms; p; p = nextSibling(p)) {
     String *v;
-    if (Getattr(p,"default")) continue;
+    if (Getattr(p,k_default)) continue;
     if (p != parms) Append(t,",");
-    v = Getattr(p,"value");
+    v = Getattr(p,k_value);
     if (v) {
       Append(t,v);
     } else {
-      Append(t,Getattr(p,"type"));
+      Append(t,Getattr(p,k_type));
     }
   }
   Append(t,")>");