/* ----------------------------------------------------------------------------- 
 * See the LICENSE file for information on copyright, usage and redistribution
 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 *
 * naming.c
 *
 * Functions for generating various kinds of names during code generation.
 * ----------------------------------------------------------------------------- */

char cvsroot_naming_c[] = "$Header$";

#include "swig.h"
#include "cparse.h"
#include "swigkeys.h"
#include <ctype.h>

/* Hash table containing naming data */

static Hash *naming_hash = 0;

#if 0
#define SWIG_DEBUG 
#endif

/* -----------------------------------------------------------------------------
 * Swig_name_register()
 *
 * Register a new naming format.
 * ----------------------------------------------------------------------------- */

void
Swig_name_register(const String_or_char *method, const String_or_char *format) {
  if (!naming_hash) naming_hash = NewHash();
  Setattr(naming_hash,method,format);
}

void
Swig_name_unregister(const String_or_char *method) {
  if (naming_hash) {
    Delattr(naming_hash,method);
  }
}

static int name_mangle(String *r) {
  char  *c;
  int    special;
  special = 0;
  Replaceall(r,"::","_");
  c = Char(r);
  while (*c) {
    if (!isalnum((int) *c) && (*c != '_')) {
      special = 1;
      switch(*c) {
      case '+':
	*c = 'a';
	break;
      case '-':
	*c = 's';
	break;
      case '*':
	*c = 'm';
	break;
      case '/':
	*c = 'd';
	break;
      case '<':
	*c = 'l';
	break;
      case '>':
	*c = 'g';
	break;
      case '=':
	*c = 'e';
	break;
      case ',':
	*c = 'c';
	break;
      case '(':
	*c = 'p';
	break;
      case ')':
	*c = 'P';
	break;
      case '[':
	*c = 'b';
	break;
      case ']':
	*c = 'B';
	break;
      case '^':
	*c = 'x';
	break;
      case '&':
	*c = 'A';
	break;
      case '|':
	*c = 'o';
	break;
      case '~':
	*c = 'n';
	break;
      case '!':
	*c = 'N';
	break;
      case '%':
	*c = 'M';
	break;
      case '.':
	*c = 'f';
	break;
      case '?':
	*c = 'q';
	break;
      default:
	*c = '_';
	break;
      }
    }
    c++;
  }
  if (special) Append(r,"___");
  return special;
}

/* -----------------------------------------------------------------------------
 * Swig_name_mangle()
 *
 * Converts all of the non-identifier characters of a string to underscores.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_mangle(const String_or_char *s) {
#if 0
  String *r = NewString(s);
  name_mangle(r);
  return r;
#else
  return Swig_string_mangle(s);
#endif
}

/* -----------------------------------------------------------------------------
 * Swig_name_wrapper()
 *
 * Returns the name of a wrapper function.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_wrapper(const String_or_char *fname) {
  String *r;
  String *f;

  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_wrapper);
  if (!f) {
    Append(r,"_wrap_%f");
  } else {
    Append(r,f);
  }
  Replace(r,"%f",fname, DOH_REPLACE_ANY);
  name_mangle(r);
  return r;
}


/* -----------------------------------------------------------------------------
 * Swig_name_member()
 *
 * Returns the name of a class method.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_member(const String_or_char *classname, const String_or_char *mname) {
  String *r;
  String *f;
  String *rclassname;
  char   *cname;

  rclassname = SwigType_namestr(classname);
  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_member);
  if (!f) {
    Append(r,"%c_%m");
  } else {
    Append(r,f);
  }
  cname = Char(rclassname);
  if ((strncmp(cname,"struct ", 7) == 0) ||
      ((strncmp(cname,"class ", 6) == 0)) ||
      ((strncmp(cname,"union ", 6) == 0))) {
    cname = strchr(cname, ' ')+1;
  }
  Replace(r,"%c",cname, DOH_REPLACE_ANY);
  Replace(r,"%m",mname, DOH_REPLACE_ANY);
  /*  name_mangle(r);*/
  Delete(rclassname);
  return r;
}

/* -----------------------------------------------------------------------------
 * Swig_name_get()
 *
 * Returns the name of the accessor function used to get a variable.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_get(const String_or_char *vname) {
  String *r;
  String *f;

#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_name_get:  '%s'\n", vname); 
#endif

  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = Getattr(naming_hash,k_get);
  if (!f) {
    Append(r,"%v_get");
  } else {
    Append(r,f);
  }
  Replace(r,"%v",vname, DOH_REPLACE_ANY);
  /* name_mangle(r); */
  return r;
}

/* ----------------------------------------------------------------------------- 
 * Swig_name_set()
 *
 * Returns the name of the accessor function used to set a variable.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_set(const String_or_char *vname) {
  String *r;
  String *f;

  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_set);
  if (!f) {
    Append(r,"%v_set");
  } else {
    Append(r,f);
  }
  Replace(r,"%v",vname, DOH_REPLACE_ANY);
  /* name_mangle(r); */
  return r;
}

/* -----------------------------------------------------------------------------
 * Swig_name_construct()
 *
 * Returns the name of the accessor function used to create an object.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_construct(const String_or_char *classname) {
  String *r;
  String *f;
  String *rclassname;
  char *cname;

  rclassname = SwigType_namestr(classname);
  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_construct);
  if (!f) {
    Append(r,"new_%c");
  } else {
    Append(r,f);
  }

  cname = Char(rclassname);
  if ((strncmp(cname,"struct ", 7) == 0) ||
      ((strncmp(cname,"class ", 6) == 0)) ||
      ((strncmp(cname,"union ", 6) == 0))) {
    cname = strchr(cname, ' ')+1;
  }
  Replace(r,"%c",cname, DOH_REPLACE_ANY);
  Delete(rclassname);
  return r;
}


/* -----------------------------------------------------------------------------
 * Swig_name_copyconstructor()
 *
 * Returns the name of the accessor function used to copy an object.
 * ----------------------------------------------------------------------------- */

String *
Swig_name_copyconstructor(const String_or_char *classname) {
  String *r;
  String *f;
  String *rclassname;
  char *cname;

  rclassname = SwigType_namestr(classname);
  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_copy);
  if (!f) {
    Append(r,"copy_%c");
  } else {
    Append(r,f);
  }

  cname = Char(rclassname);
  if ((strncmp(cname,"struct ", 7) == 0) ||
      ((strncmp(cname,"class ", 6) == 0)) ||
      ((strncmp(cname,"union ", 6) == 0))) {
    cname = strchr(cname, ' ')+1;
  }

  Replace(r,"%c",cname, DOH_REPLACE_ANY);
  Delete(rclassname);
  return r;
}

/* -----------------------------------------------------------------------------
 * Swig_name_destroy()
 *
 * Returns the name of the accessor function used to destroy an object.
 * ----------------------------------------------------------------------------- */

String *Swig_name_destroy(const String_or_char *classname) {
  String *r;
  String *f;
  String *rclassname;
  char *cname;
  rclassname = SwigType_namestr(classname);
  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_destroy);
  if (!f) {
    Append(r,"delete_%c");
  } else {
    Append(r,f);
  }

  cname = Char(rclassname);
  if ((strncmp(cname,"struct ", 7) == 0) ||
      ((strncmp(cname,"class ", 6) == 0)) ||
      ((strncmp(cname,"union ", 6) == 0))) {
    cname = strchr(cname, ' ')+1;
  }
  Replace(r,"%c",cname, DOH_REPLACE_ANY);
  Delete(rclassname);
  return r;
}


/* -----------------------------------------------------------------------------
 * Swig_name_disown()
 *
 * Returns the name of the accessor function used to disown an object.
 * ----------------------------------------------------------------------------- */

String *Swig_name_disown(const String_or_char *classname) {
  String *r;
  String *f;
  String *rclassname;
  char *cname;
  rclassname = SwigType_namestr(classname);
  r = NewStringEmpty();
  if (!naming_hash) naming_hash = NewHash();
  f = HashGetAttr(naming_hash,k_disown);
  if (!f) {
    Append(r,"disown_%c");
  } else {
    Append(r,f);
  }

  cname = Char(rclassname);
  if ((strncmp(cname,"struct ", 7) == 0) ||
      ((strncmp(cname,"class ", 6) == 0)) ||
      ((strncmp(cname,"union ", 6) == 0))) {
    cname = strchr(cname, ' ')+1;
  }
  Replace(r,"%c",cname, DOH_REPLACE_ANY);
  Delete(rclassname);
  return r;
}


/* -----------------------------------------------------------------------------
 * Swig_name_object_set()
 *
 * Sets an object associated with a name and optional declarators. 
 * ----------------------------------------------------------------------------- */

void 
Swig_name_object_set(Hash *namehash, String *name, SwigType *decl, DOH *object) {
  DOH *n;

#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_name_object_set:  '%s', '%s'\n", name, decl); 
#endif
  n = HashGetAttr(namehash,name);
  if (!n) {
    n = NewHash();
    Setattr(namehash,name,n);
    Delete(n);
  }
  /* Add an object based on the declarator value */
  if (!decl) {
    Setattr(n,k_start,object);
  } else {
    SwigType *cd = Copy(decl);
    Setattr(n,cd,object);
    Delete(cd);
  }
}


/* -----------------------------------------------------------------------------
 * Swig_name_object_get()
 *
 * Return an object associated with an optional class prefix, name, and 
 * declarator.   This function operates according to name matching rules
 * described for the %rename directive in the SWIG manual.
 * ----------------------------------------------------------------------------- */

static DOH *get_object(Hash *n, String *decl) {
  DOH *rn = 0;
  if (!n) return 0;
  if (decl) {
    rn = Getattr(n,decl);
  } else {
    rn = Getattr(n,k_start);
  }
  return rn;
}

static
DOH *
name_object_get(Hash *namehash, String *tname, SwigType *decl, SwigType *ncdecl) {
  DOH* rn = 0;
  Hash   *n = Getattr(namehash,tname);
  if (n) {
    rn = get_object(n,decl);
    if ((!rn) && ncdecl) rn = get_object(n,ncdecl);
    if (!rn) rn = get_object(n,0);
  }
  return rn;
}

DOH *
Swig_name_object_get(Hash *namehash, String *prefix, String *name, SwigType *decl) {
  String *tname = NewStringEmpty();
  DOH    *rn = 0;
  char   *ncdecl = 0;

  if (!namehash) return 0;

  /* DB: This removed to more tightly control feature/name matching */
  /*  if ((decl) && (SwigType_isqualifier(decl))) {
    ncdecl = strchr(Char(decl),'.');
    ncdecl++;
  }
  */
#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_name_object_get:  '%s', '%s'\n", name, decl); 
#endif


  /* Perform a class-based lookup (if class prefix supplied) */
  if (prefix) {
    if (Len(prefix)) {
      Printf(tname,"%s::%s", prefix, name);
      rn = name_object_get(namehash, tname, decl, ncdecl);
      if (!rn) {
	String *cls = Swig_scopename_last(prefix);
	if (!Equal(cls,prefix)) {
	  Clear(tname);
	  Printf(tname,"*::%s::%s",cls,name);
	  rn = name_object_get(namehash, tname, decl, ncdecl);
	}
	Delete(cls);
      }
      /* A template-based class lookup, check name first */
      if (!rn && SwigType_istemplate(name)) {
	String *t_name = SwigType_templateprefix(name);
	if (!Equal(t_name,name)) {
	  rn = Swig_name_object_get(namehash, prefix, t_name, decl);
	}
	Delete(t_name);
      }
      /* A template-based class lookup */
      if (0 && !rn && SwigType_istemplate(prefix)) {
	String *t_prefix = SwigType_templateprefix(prefix);
	if (Strcmp(t_prefix,prefix) != 0) {
	  String *t_name = SwigType_templateprefix(name);
	  rn = Swig_name_object_get(namehash, t_prefix, t_name, decl);
	  Delete(t_name);
	}
	Delete(t_prefix);
      }
    } 
    /* A wildcard-based class lookup */
    if (!rn) {
      Clear(tname);
      Printf(tname,"*::%s",name);
      rn = name_object_get(namehash, tname, decl, ncdecl);
    }
  } else {
    /* Lookup in the global namespace only */
    Clear(tname);
    Printf(tname,"::%s",name);
    rn = name_object_get(namehash, tname, decl, ncdecl);
  }
  /* Catch-all */
  if (!rn) {
    rn = name_object_get(namehash, name, decl, ncdecl);
  }
  if (!rn && Swig_scopename_check(name)) {
    String *nprefix = NewStringEmpty();
    String *nlast = NewStringEmpty();
    Swig_scopename_split(name, &nprefix, &nlast);
    rn = name_object_get(namehash, nlast, decl, ncdecl);
    Delete(nlast);
    Delete(nprefix);
  }
  
  Delete(tname);

#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_name_object_get:  found %d\n", rn ? 1 : 0); 
#endif

  return rn;
}

/* -----------------------------------------------------------------------------
 * Swig_name_object_inherit()
 *
 * Implements name-based inheritance scheme. 
 * ----------------------------------------------------------------------------- */

void
Swig_name_object_inherit(Hash *namehash, String *base, String *derived) {
  Iterator ki;
  String *bprefix;
  String *dprefix;
  char *cbprefix;
  int   plen;

  if (!namehash) return;
  
  bprefix = NewStringf("%s::",base);
  dprefix = NewStringf("%s::",derived);
  cbprefix = Char(bprefix);
  plen = strlen(cbprefix);
  for (ki = First(namehash); ki.key; ki = Next(ki)) {
    char *k = Char(ki.key);
    if (strncmp(k,cbprefix,plen) == 0) {
      Iterator oi;
      String *nkey = NewStringf("%s%s",dprefix,k+plen);
      Hash *n = ki.item;
      Hash *newh = HashGetAttr(namehash,nkey);
      if (!newh) {
	newh = NewHash();
	Setattr(namehash,nkey,newh);
	Delete(newh);
      }
      for (oi = First(n); oi.key; oi = Next(oi)) {
	if (!Getattr(newh,oi.key)) {
	  String *ci = Copy(oi.item);
	  Setattr(newh,oi.key,ci);
	  Delete(ci);
	}
      }
      Delete(nkey);
    }
  }
  Delete(bprefix);
  Delete(dprefix);
}

/* -----------------------------------------------------------------------------
 * merge_features()
 *
 * Given a hash, this function merges the features in the hash into the node.
 * ----------------------------------------------------------------------------- */

static void merge_features(Hash *features, Node *n) {
  Iterator ki;

  if (!features) return;
  for (ki = First(features); ki.key; ki = Next(ki)) {
    String *ci = Copy(ki.item);    
    Setattr(n,ki.key,ci);
    Delete(ci);
  }
}

/* -----------------------------------------------------------------------------
 * Swig_features_get()
 *
 * Attaches any features in the features hash to the node that matches
 * the declaration, decl.
 * ----------------------------------------------------------------------------- */

static 
void features_get(Hash *features, String *tname, SwigType *decl, SwigType *ncdecl, Node *node)
{
  Node *n = Getattr(features,tname);
#ifdef SWIG_DEBUG
  Printf(stderr,"  features_get: %s\n", tname);
#endif
  if (n) {
    merge_features(get_object(n,0),node);
    if (ncdecl) merge_features(get_object(n,ncdecl),node);
    merge_features(get_object(n,decl),node);
  }
}

void
Swig_features_get(Hash *features, String *prefix, String *name, SwigType *decl, Node *node) {
  char   *ncdecl = 0;
  String *rdecl = 0;
  String *rname = 0;
  if (!features) return;

  /* MM: This removed to more tightly control feature/name matching */
  /*
  if ((decl) && (SwigType_isqualifier(decl))) {
    ncdecl = strchr(Char(decl),'.');
    ncdecl++;
  }
  */

  /* very specific hack for template constructors/destructors */
  if (name && SwigType_istemplate(name)) {
    String *nodetype = Getattr(node, k_nodetype);
    if (nodetype && (Equal(nodetype,k_constructor) || Equal(nodetype,k_destructor))) {
      String *nprefix = NewStringEmpty();
      String *nlast = NewStringEmpty();
      String *tprefix;
      Swig_scopename_split(name, &nprefix, &nlast);    
      tprefix = SwigType_templateprefix(nlast);
      Delete(nlast);
      if (Len(nprefix)) {
	Append(nprefix,"::");
	Append(nprefix,tprefix);
	Delete(tprefix);
	rname = nprefix;      
      } else {
	rname = tprefix;
	Delete(nprefix);
      }
      rdecl = Copy(decl);
      Replaceall(rdecl,name,rname);
      decl = rdecl;
      name = rname;
    }
  }

  
#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_features_get: %s %s %s\n", prefix, name, decl);
#endif

  /* Global features */
  features_get(features, empty_string, 0, 0, node);
  if (name) {
    String *tname = NewStringEmpty();
    /* add features for 'root' template */
    if (SwigType_istemplate(name)) {
      String *dname = SwigType_templateprefix(name);
      features_get(features, dname, decl, ncdecl, node);
      Delete(dname);
    }
    /* Catch-all */
    features_get(features, name, decl, ncdecl, node);
    /* Perform a class-based lookup (if class prefix supplied) */
    if (prefix) {
      /* A class-generic feature */
      if (Len(prefix)) {
	Printf(tname,"%s::",prefix);
	features_get(features, tname, decl, ncdecl, node);
      }
      /* A wildcard-based class lookup */
      Clear(tname);
      Printf(tname,"*::%s",name);
      features_get(features, tname, decl, ncdecl, node);
      /* A specific class lookup */
      if (Len(prefix)) {
	/* A template-based class lookup */
	if (SwigType_istemplate(prefix)) {
	  String *tprefix = SwigType_templateprefix(prefix);
	  Clear(tname);
	  Printf(tname,"%s::%s",tprefix,name);
	  features_get(features, tname, decl, ncdecl, node);
	  Delete(tprefix);
	}
	Clear(tname);
	Printf(tname,"%s::%s",prefix,name);
	features_get(features, tname, decl, ncdecl, node);
      }
    } else {
      /* Lookup in the global namespace only */
      Clear(tname);
      Printf(tname,"::%s",name);
      features_get(features, tname, decl, ncdecl, node);
    }
    Delete(tname);
  }
  if (name && SwigType_istemplate(name)) {
    /* add features for complete template type */
    String *dname = Swig_symbol_template_deftype(name,0);
    if (!Equal(dname,name)) {    
      Swig_features_get(features, prefix, dname, decl, node);
    }
    Delete(dname);
  }

  if (rname) Delete(rname);
  if (rdecl) Delete(rdecl);
}


/* -----------------------------------------------------------------------------
 * Swig_feature_set()
 *
 * Sets a feature name and value. Also sets optional feature attributes as
 * passed in by featureattribs. Optional feature attributes are given a full name
 * concatenating the feature name plus ':' plus the attribute name.
 * ----------------------------------------------------------------------------- */

void 
Swig_feature_set(Hash *features, const String_or_char *name, SwigType *decl, const String_or_char *featurename, String *value, Hash *featureattribs) {
  Hash *n;
  Hash *fhash;

#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_feature_set: %s %s %s %s\n", name, decl, featurename,value);  
#endif

  n = Getattr(features,name);
  if (!n) {
    n = NewHash();
    Setattr(features,name,n);
    Delete(n);
  }
  if (!decl) {
    fhash = Getattr(n,k_start);
    if (!fhash) {
      fhash = NewHash();
      Setattr(n,k_start,fhash);
      Delete(fhash);
    }
  } else {
    fhash = Getattr(n,decl);
    if (!fhash) {
      String *cdecl_ = Copy(decl);
      fhash = NewHash();
      Setattr(n,cdecl_,fhash);
      Delete(cdecl_);
      Delete(fhash);
    }
  }
  if (value) {
    Setattr(fhash,featurename,value);
  } else {
    Delattr(fhash,featurename);
  }

  {
    /* Add in the optional feature attributes */
    Hash *attribs = featureattribs;
    while(attribs) {
      String *attribname = Getattr(attribs,k_name);
      String *featureattribname = NewStringf("%s:%s", featurename, attribname);
      if (value) {
        String *attribvalue = Getattr(attribs,k_value);
        Setattr(fhash,featureattribname,attribvalue);
      } else {
        Delattr(fhash,featureattribname);
      }
      attribs = nextSibling(attribs);
      Delete(featureattribname);
    }
  }

  if (name && SwigType_istemplate(name)) {
    String *dname = Swig_symbol_template_deftype(name,0);
    if (Strcmp(dname,name)) {    
      Swig_feature_set(features, dname, decl, featurename, value, featureattribs);
    }
    Delete(dname);
  }
}

/* -----------------------------------------------------------------------------
 * The rename/namewarn engine
 *
 * Code below was in parser.y for a while
 * ----------------------------------------------------------------------------- */

static Hash   *namewarn_hash = 0;
Hash *Swig_name_namewarn_hash() {
  if (!namewarn_hash) namewarn_hash = NewHash();
  return namewarn_hash;
}

static Hash   *rename_hash = 0;
Hash *Swig_name_rename_hash() {
  if (!rename_hash) rename_hash = NewHash();
  return rename_hash;
}

static List   *namewarn_list = 0;
List *Swig_name_namewarn_list() {
  if (!namewarn_list) namewarn_list = NewList();
  return namewarn_list;
}

static List   *rename_list = 0;
List *Swig_name_rename_list() {
  if (!rename_list) rename_list = NewList();
  return rename_list;
}

/* -----------------------------------------------------------------------------
 * int Swig_need_name_warning(Node *n)
 *
 * Detects if a node needs name warnings 
 *
 * ----------------------------------------------------------------------------- */

int Swig_need_name_warning(Node *n)
{
  int need = 1;
  /* 
     we don't use name warnings for:
     - class forwards, no symbol is generated at the target language.
     - template declarations, only for real instances using %template(name).
     - typedefs, they have no effect at the target language.
  */
  if (checkAttribute(n,k_nodetype,k_classforward)) {
    need = 0;
  } else if (checkAttribute(n,k_storage,k_typedef))  {
    need = 0;
  } else if (Getattr(n,k_hidden)) {
    need = 0;
  } else if (Getattr(n,k_ignore)) {
    need = 0;
  } else if (Getattr(n,k_templatetype)) {
    need = 0;
  }
  return need;
}

/* -----------------------------------------------------------------------------
 * int Swig_need_redefined_warn()
 *
 * Detects when a redefined object needs a warning
 * 
 * ----------------------------------------------------------------------------- */

static int nodes_are_equivalent(Node* a, Node* b, int a_inclass)
{
  /* they must have the same type */
  String *ta = Getattr(a,k_nodetype);
  String *tb = Getattr(b,k_nodetype);  
  if (Cmp(ta, tb) != 0) return 0;
  
  /* cdecl case */
  if (Cmp(ta, k_cdecl) == 0) {
    /* typedef */
    String *a_storage = Getattr(a,k_storage);
    String *b_storage = Getattr(b,k_storage);

    if ((Cmp(a_storage,k_typedef) == 0)
	|| (Cmp(b_storage,k_typedef) == 0)) {	
      if (Cmp(a_storage, b_storage) == 0) {
	String *a_type = (Getattr(a,k_type));
	String *b_type = (Getattr(b,k_type));
	if (Cmp(a_type, b_type) == 0) return 1;
      }
      return 0;
    }

    /* static functions */
    if ((Cmp(a_storage, k_static) == 0) 
	|| (Cmp(b_storage, k_static) == 0)) {
      if (Cmp(a_storage, b_storage) != 0) return 0;
    }

    /* friend methods */
    
    if (!a_inclass || (Cmp(a_storage,k_friend) == 0)) {
      /* check declaration */

      String *a_decl = (Getattr(a,k_decl));
      String *b_decl = (Getattr(b,k_decl));
      if (Cmp(a_decl, b_decl) == 0) {
	/* check return type */
	String *a_type = (Getattr(a,k_type));
	String *b_type = (Getattr(b,k_type));
	if (Cmp(a_type, b_type) == 0) {
	  /* check parameters */
	  Parm *ap = (Getattr(a,k_parms));
	  Parm *bp = (Getattr(b,k_parms));
	  while (ap && bp) {
	    SwigType *at = Getattr(ap,k_type);
	    SwigType *bt = Getattr(bp,k_type);
	    if (Cmp(at, bt) != 0) return 0;
	    ap = nextSibling(ap);
	    bp = nextSibling(bp);
	  }
	  if (ap || bp) {
	    return 0;
	  } else {
            Node *a_template = Getattr(a,k_template);
            Node *b_template = Getattr(b,k_template);
            /* Not equivalent if one is a template instantiation (via %template) and the other is a non-templated function */
            if ((a_template && !b_template) || (!a_template && b_template)) return 0;
          }
	  return 1;
	}
      }
    }
  } else {
    /* %constant case */  
    String *a_storage = Getattr(a,k_storage);
    String *b_storage = Getattr(b,k_storage);
    if ((Cmp(a_storage, "%constant") == 0) 
	|| (Cmp(b_storage, "%constant") == 0)) {
      if (Cmp(a_storage, b_storage) == 0) {
	String *a_type = (Getattr(a,k_type));
	String *b_type = (Getattr(b,k_type));
	if ((Cmp(a_type, b_type) == 0)
	    && (Cmp(Getattr(a,k_value), Getattr(b,k_value)) == 0))
	  return 1;
      }
      return 0;
    }
  }
  return 0;
}

int Swig_need_redefined_warn(Node* a, Node* b, int InClass)
{
  String *a_name = Getattr(a,k_name);
  String *b_name = Getattr(b,k_name);
  String *a_symname = Getattr(a,k_symname);
  String *b_symname = Getattr(b,k_symname);
  /* always send a warning if a 'rename' is involved */
  if ((a_symname && !Equal(a_symname,a_name))
      || (b_symname && !Equal(b_symname,b_name))) {
    if (!Equal(a_name,b_name)) {
      return 1;
    }
  }
  

  return !nodes_are_equivalent(a, b, InClass);
}


/* -----------------------------------------------------------------------------
 * int Swig_need_protected(Node* n)
 *
 * Detects when we need to fully register the protected member.
 * 
 * ----------------------------------------------------------------------------- */

int Swig_need_protected(Node* n)
{
  /* First, 'n' looks like a function */
  /* if (!Swig_director_mode()) return 0; */
  String *nodetype = Getattr(n,k_nodetype);
  if ((Equal(nodetype,k_cdecl)) && SwigType_isfunction(Getattr(n,k_decl))) {
    String *storage = Getattr(n,k_storage);
    /* and the function is declared like virtual, or it has no
       storage. This eliminates typedef, static and so on. */ 
    return !storage || Equal(storage,k_virtual);
  } else if (Equal(nodetype,k_constructor) || Equal(nodetype,k_destructor)) {
    return 1;
  }

  return 0;
}

/* -----------------------------------------------------------------------------
 * void Swig_name_nameobj_add()
 *
 * Add nameobj (rename/namewarn)
 * 
 * ----------------------------------------------------------------------------- */

static List *Swig_make_attrlist(const char *ckey) {
  List *list = NewList();
  const char *cattr = strchr(ckey,'$');
  if (cattr) {
    String *nattr;
    const char *rattr = strchr(++cattr,'$');
    while (rattr) {
      nattr = NewStringWithSize(cattr, rattr-cattr);
      Append(list,nattr);
      Delete(nattr);
      cattr = rattr + 1;
      rattr = strchr(cattr,'$');
    }
    nattr = NewString(cattr);
    Append(list,nattr);
    Delete(nattr);
  } else {
    Append(list,k_nodetype);
  }
  return list;
}

static void Swig_name_object_attach_keys(const char *keys[], Hash *nameobj) 
{
  Node *kw = nextSibling(nameobj);
  List *matchlist = 0;
  while (kw) {
    Node *next = nextSibling(kw);
    String *kname = Getattr(kw,k_name);
    char *ckey = kname ? Char(kname) :  0;
    if (ckey) {
      const char **rkey;
      int isnotmatch = 0;
      int isrxsmatch = 0;      
      if ((strncmp(ckey,"match",5) == 0) 
	  || (isnotmatch = (strncmp(ckey,"notmatch",8) == 0))
	  || (isrxsmatch = (strncmp(ckey,"rxsmatch",8) == 0))
	  || (isnotmatch = isrxsmatch = (strncmp(ckey,"notrxsmatch",11) == 0))) {
	Hash *mi = NewHash();
	List *attrlist = Swig_make_attrlist(ckey);
	if (!matchlist) matchlist = NewList();
	Setattr(mi,k_value,Getattr(kw,k_value));
	Setattr(mi,k_attrlist,attrlist);
#ifdef SWIG_DEBUG 
	if (isrxsmatch) Printf(stderr,"rxsmatch to use: %s %s %s\n", ckey, Getattr(kw,k_value), attrlist);
#endif
	if (isnotmatch) SetFlag(mi,k_notmatch);
	if (isrxsmatch) SetFlag(mi,k_rxsmatch);
	Delete(attrlist);
	Append(matchlist,mi);
	Delete(mi);
	deleteNode(kw);
      } else {
	for (rkey = keys; *rkey != 0; ++rkey) {
	  if (strcmp(ckey,*rkey) == 0) {
	    Setattr(nameobj, *rkey, Getattr(kw,k_value));
	    deleteNode(kw);
	  }
	}
      }
    }
    kw = next;
  }
  if (matchlist) {
    Setattr(nameobj,k_matchlist,matchlist);
    Delete(matchlist);
  }
}

void Swig_name_nameobj_add(Hash *name_hash, List *name_list,
			   String *prefix, String *name, SwigType *decl, Hash *nameobj) {
  String *nname = 0;
  if (name && Len(name)) {
    String *target_fmt = Getattr(nameobj,k_targetfmt);
    nname = prefix ? NewStringf("%s::%s",prefix, name) : NewString(name);
    if (target_fmt) {
      String *tmp = NewStringf(target_fmt, nname);
      Delete(nname);
      nname = tmp;
    }
  }  
  
  if (!nname || !Len(nname) || 
      Getattr(nameobj,k_fullname)  ||  /* any of these options trigger a 'list' nameobj */
      Getattr(nameobj,k_sourcefmt) || 
      Getattr(nameobj,k_matchlist)) {
    if (decl) Setattr(nameobj,k_decl, decl);
    if (nname && Len(nname)) Setattr(nameobj,k_targetname, nname);
    /* put the new nameobj at the beginnig of the list, such that the
       last inserted rule take precedence */
    Insert(name_list, 0, nameobj);
  } else {
    /* here we add an old 'hash' nameobj, simple and fast */
    Swig_name_object_set(name_hash,nname,decl,nameobj);
  }
  Delete(nname);
}

/* -----------------------------------------------------------------------------
 * int Swig_name_match_nameobj()
 *
 * Apply and check the nameobj's math list to the node
 * 
 * ----------------------------------------------------------------------------- */

static DOH *Swig_get_lattr(Node *n, List *lattr)
{
  DOH *res = 0;
  int ilen = Len(lattr);
  int i;
  for (i = 0; n && (i < ilen); ++i) {
    String *nattr = Getitem(lattr,i);
    res = Getattr(n,nattr);
#ifdef SWIG_DEBUG 
    if (!res) {
      Printf(stderr,"missing %s %s %s\n",nattr, Getattr(n,k_name), Getattr(n,"member"));
    } else {    
      Printf(stderr,"lattr %d %s %s\n",i, nattr, DohIsString(res) ? res : Getattr(res,k_name));
    }
#endif
    n = res;
  }
  return res;
}

#if defined(HAVE_RXSPENCER)
#include <sys/types.h>
#include <rxspencer/regex.h>
#define USE_RXSPENCER
#endif

#if defined(USE_RXSPENCER)
int Swig_name_rxsmatch_value(String *mvalue, String *value)
{
  int match = 0;
  char *cvalue = Char(value);
  char *cmvalue = Char(mvalue);
  regex_t compiled;
  int retval = regcomp(&compiled, cmvalue, REG_EXTENDED|REG_NOSUB);
  if(retval != 0) return 0;
  retval = regexec(&compiled,cvalue,0,0,0);
  match = (retval == REG_NOMATCH) ? 0 : 1;
#ifdef SWIG_DEBUG
  Printf(stderr,"rxsmatch_value: %s %s %d\n",cvalue,cmvalue, match);
#endif
  regfree(&compiled);
  return match;
}
#else
int Swig_name_rxsmatch_value(String *mvalue, String *value)
{
  (void)mvalue;
  (void)value;  
  return 0;
}
#endif

int Swig_name_match_value(String *mvalue, String *value)
{
#if defined(SWIG_USE_SIMPLE_MATCHOR)
  int match = 0;
  char *cvalue = Char(value);
  char *cmvalue = Char(mvalue);
  char *sep = strchr(cmvalue,'|');
  while (sep && !match) {
    match = strncmp(cvalue,cmvalue, sep - cmvalue) == 0;
#ifdef SWIG_DEBUG 
    Printf(stderr,"match_value: %s %s %d\n",cvalue,cmvalue, match);
#endif
    cmvalue = sep + 1;
    sep = strchr(cmvalue,'|');
  }
  if (!match) {
    match = strcmp(cvalue,cmvalue) == 0;    
#ifdef SWIG_DEBUG 
    Printf(stderr,"match_value: %s %s %d\n",cvalue,cmvalue, match);
#endif
  }
  return match;
#else
  return StringEqual(mvalue,value);
#endif
}


int Swig_name_match_nameobj(Hash *rn, Node *n) {
  int match = 1;
  List *matchlist = HashGetAttr(rn,k_matchlist);
#ifdef SWIG_DEBUG 
  Printf(stderr,"Swig_name_match_nameobj: %s\n",Getattr(n,"name"));
#endif
  if (matchlist) {
    int ilen = Len(matchlist);
    int i;
    for (i = 0; match && (i < ilen); ++i) {
      Node *mi = Getitem(matchlist,i);
      List *lattr = Getattr(mi,k_attrlist);
      String *nval = Swig_get_lattr(n,lattr);
      int notmatch = GetFlag(mi,k_notmatch);
      int rxsmatch = GetFlag(mi,k_rxsmatch);
#ifdef SWIG_DEBUG 
      Printf(stderr,"mi %d %s re %d not %d \n", i, nval, notmatch, rxsmatch);
      if (rxsmatch) {
	Printf(stderr,"rxsmatch %s\n",lattr);
      }      
#endif
      match = 0;
      if (nval) {
	String *kwval = Getattr(mi,k_value);
	match = rxsmatch ? Swig_name_rxsmatch_value(kwval, nval) 
	  : Swig_name_match_value(kwval, nval);
#ifdef SWIG_DEBUG 
	Printf(stderr,"val %s %s %d %d \n",nval, kwval,match, ilen);
#endif
      }
      if (notmatch) match = !match;
    }
  }
#ifdef SWIG_DEBUG 
  Printf(stderr,"Swig_name_match_nameobj: %d\n",match);
#endif
  return match;
}

/* -----------------------------------------------------------------------------
 * Hash *Swig_name_nameobj_lget()
 *
 * Get a nameobj (rename/namewarn) from the list of filters
 * 
 * ----------------------------------------------------------------------------- */

Hash *Swig_name_nameobj_lget(List *namelist, Node *n, String *prefix, String *name, String *decl) {
  Hash *res = 0;
  if (namelist) {
    int len = Len(namelist);
    int i;
    int match = 0;
    for (i = 0; !match && (i < len); i++) {
      Hash *rn = Getitem(namelist,i);
      String *rdecl = HashGetAttr(rn,k_decl);
      if (rdecl && (!decl || !Equal(rdecl,decl))) {
	continue;
      } else if (Swig_name_match_nameobj(rn, n)) {
	String *tname = HashGetAttr(rn,k_targetname);
	if (tname) {
	  String *sfmt = HashGetAttr(rn,k_sourcefmt);
	  String *sname = 0;
	  int fullname = GetFlag(rn,k_fullname);
	  int rxstarget = GetFlag(rn,k_rxstarget);
	  if (sfmt) {
	    if (fullname && prefix) {
	      String *pname= NewStringf("%s::%s", prefix, name);
	      sname = NewStringf(sfmt, pname);
	      Delete(pname);
	    } else {
	      sname = NewStringf(sfmt, name);
	    }
	  } else {
	    if (fullname && prefix) {
	      sname = NewStringf("%s::%s", prefix, name);
	    } else {
	      sname = name;
	      DohIncref(name);
	    }
	  }
	  match = rxstarget ? Swig_name_rxsmatch_value(tname,sname) :
	    Swig_name_match_value(tname,sname);
	  Delete(sname);
	} else {
	  match = 1;
	}
      }
      if (match) {
	res = rn;
	break;
      }
    }
  }
  return res;
}

/* -----------------------------------------------------------------------------
 * Swig_name_namewarn_add
 *
 * Add a namewarn objects
 * 
 * ----------------------------------------------------------------------------- */

void Swig_name_namewarn_add(String *prefix, String *name, SwigType *decl, Hash *namewrn) {
  const char *namewrn_keys[] = {"rename", "error", "fullname", "sourcefmt", "targetfmt", 0};
  Swig_name_object_attach_keys(namewrn_keys, namewrn);
  Swig_name_nameobj_add(Swig_name_namewarn_hash(), Swig_name_namewarn_list(),
			prefix, name, decl, namewrn);
}

/* -----------------------------------------------------------------------------
 * Hash *Swig_name_namewarn_get()
 *
 * Return the namewarn object, if there is one.
 * 
 * ----------------------------------------------------------------------------- */

Hash *Swig_name_namewarn_get(Node *n, String *prefix, String *name,SwigType *decl) {
  if (!namewarn_hash && !namewarn_list) return 0;
  if (n) {
    /* Return in the obvious cases */
    if (!name || !Swig_need_name_warning(n)) {
      return 0;
    } else {
      String *access = Getattr(n,k_access);	
      int is_public = !access || Equal(access,k_public);
      if (!is_public && !Swig_need_protected(n)) {
	return 0;
      }
    }
  }
  if (name) {
    /* Check to see if the name is in the hash */
    Hash *wrn = Swig_name_object_get(Swig_name_namewarn_hash(),prefix,name,decl);
    if (wrn && !Swig_name_match_nameobj(wrn, n)) wrn = 0;
    if (!wrn) {
      wrn = Swig_name_nameobj_lget(Swig_name_namewarn_list(), n, prefix, name, decl);
    }
    if (wrn && HashGetAttr(wrn,k_error)) {
      if (n) {
	Swig_error(Getfile(n), Getline(n), "%s\n", HashGetAttr(wrn,k_name));
      } else {
	Swig_error(cparse_file, cparse_line,"%s\n", HashGetAttr(wrn,k_name));
      }
    } 
    return wrn;
  } else {
    return 0;
  }
}

/* -----------------------------------------------------------------------------
 * String *Swig_name_warning()
 *
 * Return the name warning, if there is one.
 * 
 * ----------------------------------------------------------------------------- */

String *Swig_name_warning(Node *n, String *prefix, String *name,SwigType *decl) {
  Hash *wrn = Swig_name_namewarn_get(n, prefix, name,decl);
  return (name && wrn) ? HashGetAttr(wrn,k_name) : 0;
}

/* -----------------------------------------------------------------------------
 * Swig_name_rename_add()
 *
 * Manage the rename objects
 * 
 * ----------------------------------------------------------------------------- */

static void single_rename_add(String *prefix, String *name, SwigType *decl, Hash *newname) {
  Swig_name_nameobj_add(Swig_name_rename_hash(), Swig_name_rename_list(),
			prefix, name, decl, newname);
}

/* Add a new rename. Works much like new_feature including default argument handling. */
void Swig_name_rename_add(String *prefix, String *name, SwigType *decl, Hash *newname, 
			  ParmList *declaratorparms) {
  
  ParmList *declparms = declaratorparms;
  
  const char *rename_keys[] = {"fullname", "sourcefmt", "targetfmt", "continue", "rxstarget",0};
  Swig_name_object_attach_keys(rename_keys, newname);
  
  /* Add the name */
  single_rename_add(prefix, name, decl, newname);
  
  /* Add extra names if there are default parameters in the parameter list */
  if (decl) {
    int constqualifier = SwigType_isconst(decl);
    while (declparms) {
      if (ParmList_has_defaultargs(declparms)) {
	
        /* Create a parameter list for the new rename by copying all
           but the last (defaulted) parameter */
        ParmList* newparms = ParmList_copy_all_except_last_parm(declparms);
	
        /* Create new declaration - with the last parameter removed */
        SwigType *newdecl = Copy(decl);
        Delete(SwigType_pop_function(newdecl)); /* remove the old parameter list from newdecl */
        SwigType_add_function(newdecl,newparms);
        if (constqualifier)
          SwigType_add_qualifier(newdecl,"const");
	
        single_rename_add(prefix, name, newdecl, newname);
        declparms = newparms;
        Delete(newdecl);
      } else {
        declparms = 0;
      }
    }
  }
}

/* -----------------------------------------------------------------------------
 * String *Swig_name_make()
 *
 * Make a name after applying all the rename/namewarn objects
 * 
 * ----------------------------------------------------------------------------- */

/* Create a name applying rename/namewarn if needed */
static String *apply_rename(String *newname, int fullname, String *prefix, String *name)
{
  String *result = 0;
  if (newname && Len(newname)) {
    if (Strcmp(newname,"$ignore") == 0) {
      result = Copy(newname);
    } else {
      char *cnewname = Char(newname);
      if (cnewname) {
	int destructor = name && (*(Char(name)) == '~');
	String *fmt = newname;
	/* use name as a fmt, but avoid C++ "%" and "%=" operators */
	if (Len(newname) > 1 && strchr(cnewname,'%') && !(strcmp(cnewname,"%=") == 0)) { 
 	  if (fullname && prefix) {
	    result = NewStringf(fmt,prefix,name);
	  } else {
	    result = NewStringf(fmt,name);
	  }
	} else {
	  result = Copy(newname);
	}
	if (destructor && result && (*(Char(result)) != '~')) {
	  Insert(result,0,"~");
	}
      }
    }
  }
  
  return result;
}

String *
Swig_name_make(Node *n, String *prefix, String_or_char *cname, SwigType *decl, String *oldname) {
  String *nname = 0;
  String *result = 0;
  String *name = NewString(cname);
  Hash *wrn = 0;
  String *rdecl = 0;
  String *rname = 0;

  /* very specific hack for template constructors/destructors */
#ifdef SWIG_DEBUG
  Printf(stderr,"SWIG_name_make: looking for %s %s %s %s\n", prefix, name, decl, oldname);
#endif

  if (name && n && SwigType_istemplate(name)) {
    String *nodetype = Getattr(n, k_nodetype);
    if (nodetype && (Equal(nodetype,k_constructor) || Equal(nodetype,k_destructor))) {
      String *nprefix = NewStringEmpty();
      String *nlast = NewStringEmpty();
      String *tprefix;
      Swig_scopename_split(name, &nprefix, &nlast);    
      tprefix = SwigType_templateprefix(nlast);
      Delete(nlast);
      if (Len(nprefix)) {
	Append(nprefix,"::");
	Append(nprefix,tprefix);
	Delete(tprefix);
	rname = nprefix;      
      } else {
	rname = tprefix;
	Delete(nprefix);
      }
      rdecl = Copy(decl);
      Replaceall(rdecl,name,rname);
#ifdef SWIG_DEBUG
      Printf(stderr,"SWIG_name_make: use new name %s %s : %s %s\n",name, decl, rname, rdecl);
#endif
      decl = rdecl;
      Delete(name);
      name = rname;
    }
  }
  

  if (rename_hash || rename_list) {
    Hash *rn =  Swig_name_object_get(Swig_name_rename_hash(), prefix, name, decl);
    if (!rn || !Swig_name_match_nameobj(rn,n)) {
      rn = Swig_name_nameobj_lget(Swig_name_rename_list(), n, prefix, name, decl);
      if (rn) {
	String *sfmt = HashGetAttr(rn,k_sourcefmt);
	int fullname = GetFlag(rn,k_fullname);
	if (fullname && prefix) {
	  String *sname = NewStringf("%s::%s", prefix, name);
	  Delete(name);
	  name = sname;
	  prefix = 0;
	}
	if (sfmt) {
	  String *sname = NewStringf(sfmt, name);
	  Delete(name);
	  name = sname;
	}
      }
    }
    if (rn) {
      String *newname = HashGetAttr(rn,k_name);
      int fullname = GetFlag(rn,k_fullname);
      result = apply_rename(newname, fullname, prefix, name);
    }
    if (result && !Equal(result,name)) {
      /* operators in C++ allow aliases, we look for them */
      char *cresult = Char(result);
      if (cresult && (strncmp(cresult,"operator ",9) == 0)) {
	String *nresult = Swig_name_make(n, prefix, result, decl, oldname);
	if (!Equal(nresult,result)) {
	  Delete(result);
	  result = nresult;
	} else {
	  Delete(nresult);
	}
      }
    }
    nname = result ? result : name;
    wrn = Swig_name_namewarn_get(n, prefix, nname, decl);
    if (wrn) {
      String *rename = HashGetAttr(wrn,k_rename);
      if (rename) {
	String *msg = HashGetAttr(wrn,k_name);
	int fullname = GetFlag(wrn,k_fullname);
	if (result) Delete(result);
	result = apply_rename(rename, fullname, prefix, name);
	if ((msg) && (Len(msg))) {
	  if (!Getmeta(nname,"already_warned")) {
	    if (n)  {
	      SWIG_WARN_NODE_BEGIN(n);
	      Swig_warning(0,Getfile(n), Getline(n), "%s\n", msg);
	      SWIG_WARN_NODE_END(n);
	    } else {
	      Swig_warning(0,Getfile(name),Getline(name), "%s\n", msg);
	    }
	    Setmeta(nname,"already_warned","1");
	  }
	}
      }
    }
  }
  if (!result || !Len(result)) {
    if (result) Delete(result);
    if (oldname) {
      result = NewString(oldname);
    } else {
      result = NewString(cname);
    }
  }
  Delete(name);
  
#ifdef SWIG_DEBUG
  Printf(stderr,"Swig_name_make: result  '%s' '%s'\n", cname, result); 
#endif

  return result;
}

/* -----------------------------------------------------------------------------
 * void Swig_name_inherit()
 *
 * Inherit namewarn,rename, and feature objects
 * 
 * ----------------------------------------------------------------------------- */

void Swig_name_inherit(String *base, String *derived) {
  /*  Printf(stderr,"base = '%s', derived = '%s'\n", base, derived); */
  Swig_name_object_inherit(Swig_name_rename_hash(),base,derived);
  Swig_name_object_inherit(Swig_name_namewarn_hash(),base,derived);
  Swig_name_object_inherit(Swig_cparse_features(),base,derived);
}