/*******************************************************************************
 * Simplified Wrapper and Interface Generator  (SWIG)
 * 
 * Author : David Beazley
 *
 * Department of Computer Science        
 * University of Chicago
 * 1100 E 58th Street
 * Chicago, IL  60637
 * beazley@cs.uchicago.edu
 *
 * Please read the file LICENSE for the copyright and terms by which SWIG
 * can be used and distributed.
 *******************************************************************************/

#include "internal.h"

#include <limits.h>

// ------------------------------------------------------------------------
// $Header: /cvsroot/SWIG1.1/SWIG/typemap.cxx,v 1.3 1999/08/08 21:36:44 beazley Exp $
//
// typemap.cxx
//
// This file provides universal support for typemaps.   Typemaps are created
// using the following SWIG command in an interface file:
//
//       %typemap(lang,operation) type { code }        Make a new typemap
//       %typemap(lang,operation) type;                Clears any previous typemap
//
// lang is an identifier indicating the target language.  The typemap will
// simply be ignored if its for a different language.  The code is the
// corresponding C code for the mapping.  An example typemap might look
// like this :
//
//       %typemap(tcl,get) double {
//              $target = atof($source);
//       }
//       %typemap(tcl,set) double {
//              sprintf($target,"%0.17f",$source);
//       }
//
// The variables $target and $source should be used in any type-mappings.
// Additional local variables can be created, but this should be done 
// by enclosing the entire code fragment in an extra set of braces.
//
// The C++ API to the type-mapper is as follows :
//
// void typemap_register(char *op, char *lang, DataType *type, char *pname, String &getcode, ParmList *args)
// char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *source, char *target);
// void typemap_clear(char *op, char *lang, DataType *type, char *pname);
//
// The lookup functions return a character string corresponding to the type-mapping
// code or NULL if none exists.   The string return will have the source and target
// strings substituted for the strings "$source" and "$target" in the type-mapping code.
//
// (2/19/97) This module has been extended somewhat to provide generic mappings
// of other parts of the code--most notably exceptions.
//
// void fragment_register(char *op, char *lang, String &code)
// char fragment_lookup(char *op, char *lang, int age);
// char fragment_clear(char *op, char *lang);
//
// ------------------------------------------------------------------------

// Structure for holding a typemap

struct TypeMap {
  char       *lang;
  DataType   *type;
  String      code;
  int         first;
  int         last;
  TypeMap     *next;
  TypeMap     *previous;                // Previously defined typemap (if any)
  ParmList    *args;                    // Local variables (if any)

  TypeMap(char *l, DataType *t, String &c, ParmList *p = 0) {
    lang = copy_string(l);
    type = new DataType(t);
    code << c;
    first = type_id;
    last = INT_MAX;
    next = 0;
    previous = 0;
    if (p) {
      args = new ParmList(p);
    } else {
      args = 0;
    }
  }
  TypeMap(char *l, DataType *t, char *c, ParmList *p = 0) {
    lang = copy_string(l);
    type = new DataType(t);
    code << c;
    first = type_id;
    last = INT_MAX;
    next = 0;
    previous = 0;
    if (p) {
      args = new ParmList(p);
    } else {
      args = 0;
    }
  }
  TypeMap(char *l, char *c) {
    lang = copy_string(l);
    type = 0;
    code << c;
    first = type_id;
    last = INT_MAX;
    next = 0;
    previous = 0;
    args = 0;
  }
  TypeMap(TypeMap *t) {
    lang = copy_string(t->lang);
    type = new DataType(t->type);
    code << t->code;
    first = type_id;
    last = INT_MAX;
    next = 0;
    previous = t->previous;
    if (args) {
      args = new ParmList(args);
    } else {
      args = 0;
    }
  }
};

// Hash tables for storing type-mappings

static Hash  typemap_hash;

// Structure for holding "applications of a typemap"

struct TmMethod {
  char *name;          // Typemap name;
  DataType *type;      // Typemap type
  TmMethod *next;      // Next method
  TmMethod(char *n, DataType *t, TmMethod *m = 0) {
    if (n) name = copy_string(n);
    else name = 0;
    if (t) {
      type = new DataType(t);
    } else {
      type = 0;
    }
    next = m;
  }
};

// Hash table for storing applications of a datatype

static Hash application_hash;

// ------------------------------------------------------------------------
// void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname)
//
// Attempts to apply a typemap given by (tm_type,tm_name) to (type,pname)
// Called by the %apply directive.
// ------------------------------------------------------------------------

void typemap_apply(DataType *tm_type, char *tm_name, DataType *type, char *pname) {
  TmMethod *m,*m1;
  char temp[512];

  // Form the application name
  if (!pname) pname = "";
  sprintf(temp,"%s$%s",type->print_type(),pname);

  // See if there is a method already defined

  m = (TmMethod *) application_hash.lookup(temp);
  
  if (!m) {
    m = new TmMethod(temp,type,0);
    application_hash.add(temp,m);
  }

  // Check to see if an array typemap has been applied to a non-array type

  if ((tm_type->arraystr) && (!type->arraystr)) {
    fprintf(stderr,"%s:%d: Warning. Array typemap has been applied to a non-array type.\n",
	    input_file,line_number);
  }

  // If both are arrays, make sure they have the same dimension 

  if ((tm_type->arraystr) && (type->arraystr)) {
    char s[128],*t;
    if (tm_type->array_dimensions() != type->array_dimensions()) {
      fprintf(stderr,"%s:%d: Warning. Array types have different number of dimensions.\n",
	      input_file,line_number);
    } else {
      for (int i = 0; i < tm_type->array_dimensions(); i++) {
	strcpy(s,tm_type->get_dimension(i));
	t = type->get_dimension(i);
	if (strcmp(s,"ANY") != 0) {
	  if (strcmp(s,t)) 
	    fprintf(stderr,"%s:%d: Warning. Array typemap applied to an array of different size.\n",
		    input_file, line_number);
	}
      }
    }
  }

  // Add a new mapping corresponding to the typemap

  m1 = new TmMethod(tm_name,tm_type,m->next);
  m->next = m1;
  
}
// ------------------------------------------------------------------------
// void typemap_clear_apply(DataType *type, char *pname)
//
// Clears the application of a typemap.
// Called by the %clear directive.
// ------------------------------------------------------------------------

void typemap_clear_apply(DataType *type, char *pname) {
  char temp[512];
  if (!pname) pname = "";
  sprintf(temp,"%s$%s", type->print_type(), pname);
  application_hash.remove(temp);
}

// ------------------------------------------------------------------------
// char *typemap_string(char *lang, DataType *type, char *pname, char *ary, char *suffix)
//
// Produces a character string corresponding to a lang, datatype, and
// method.   This string is used as the key for our typemap hash table.
// ------------------------------------------------------------------------

static char *typemap_string(char *lang, DataType *type, char *pname, char *ary, char *suffix) {
  static String str;

  int old_status;
  old_status = type->status;
  type->status = 0;
  str = "";

  if (ary)
    str << lang << type->print_type() << pname << ary << suffix;
  else
    str << lang << type->print_type() << pname << suffix;

  type->status = old_status;
  return str;
}

// ------------------------------------------------------------------------
// void typemap_register(char *op, char *lang, DataType *type, char *pname,
//                       char *getcode, ParmList *args)
//
// Register a new mapping with the type-mapper.  
// ------------------------------------------------------------------------

void typemap_register(char *op, char *lang, DataType *type, char *pname, 
                      char *getcode, ParmList *args) {
  
  char     *key;
  TypeMap  *tm,*tm_old;
  char     temp[256];
  int      is_default = 0;

  // printf("Registering : %s %s %s %s\n%s\n", op, lang, type->print_type(), pname, getcode);


  tm = new TypeMap(lang,type,getcode,args);
  // If this is a default typemap, downgrade the type!

  if (strcmp(pname,"SWIG_DEFAULT_TYPE") == 0) {
    tm->type->primitive();   
    is_default = 1;
  }

  key = typemap_string(lang,tm->type,pname,tm->type->arraystr, op);

  // Get any previous setting of the typemap

  tm_old = (TypeMap *) typemap_hash.lookup(key);

  if (tm_old) {

    // Perform a chaining operation, but only if the last typemap is
    // active.

    if (type_id < tm_old->last) {
      sprintf(temp,"$%s",op);
      tm->code.replace(temp,tm_old->code);
    }

    // If found, we need to attach the old version to the new one

    tm->previous = tm_old;
    tm->next = tm_old;
    tm_old->last = type_id;

    // Remove the old one from the hash
  
    typemap_hash.remove(key);
  } 

  // Add new typemap to the hash table
  typemap_hash.add(key,(void *) tm);

  // Now try to perform default chaining operation (if available)
  //  if (!is_default) {
  //    sprintf(temp,"$%s",op);
  //    if (strstr(tm->code,temp)) {
  //      tm->code.replace(temp,typemap_resolve_default(op,lang,type));
  //    }
  //  }

  // Just a sanity check to make sure args look okay.
  
  if (args) {
    Parm *p;
    p = tm->args->get_first();
    while (p) {
      if (p->name) {
	//	printf("    %s %s\n", p->t->print_type(),p->name);
      } else {
	fprintf(stderr,"%s:%d:  Typemap error. Local variables must have a name\n",
		input_file, line_number);
      }
      // If a call by reference thingy, fix that
      if (p->call_type & CALL_REFERENCE) {
	p->t->is_pointer--;
	p->call_type = 0;
      }
      p = tm->args->get_next();
    }
  }
}

// ------------------------------------------------------------------------
// void typemap_register(char *op, char *lang, char *type, char *pname,
//                       char *getcode, ParmList *args)
//
// Register a new mapping with the type-mapper. Special version that uses a
// string instead of a datatype.
// ------------------------------------------------------------------------

void typemap_register(char *op, char *lang, char *type, char *pname, 
                      char *getcode, ParmList *args) {
  DataType temp;
  strcpy(temp.name,type);
  temp.is_pointer = 0;
  temp.type = T_USER;
  typemap_register(op,lang,&temp,pname,getcode,args);
}


// ------------------------------------------------------------------------
// void typemap_register_default(char *op, char *lang, int type, int ptr, char *arraystr,
//                               char *code, ParmList *args)
//
// Registers a default typemap with the system using numerical type codes.
// type is the numerical code, ptr is the level of indirection. 
// ------------------------------------------------------------------------

void typemap_register_default(char *op, char *lang, int type, int ptr, char *arraystr,
			   char *code, ParmList *args) {

  DataType *t = new DataType(type);

  // Create a raw datatype from the arguments

  t->is_pointer = ptr;
  t->arraystr = copy_string(arraystr);

  // Now, go register this as a default type

  typemap_register(op,lang,t,"SWIG_DEFAULT_TYPE",code,args);
  delete t;
}


// ------------------------------------------------------------------------
// static TypeMap *typemap_search(char *key, int id) 
//
// An internal function for searching for a particular typemap given
// a key value and datatype id.
//
// Basically this checks the hash table and then checks the id against
// first and last values, looking for a match.   This is to properly
// handle scoping problems.
// ------------------------------------------------------------------------

TypeMap *typemap_search(char *key, int id) {
  
  TypeMap *tm;

  tm = (TypeMap *) typemap_hash.lookup(key);
  while (tm) {
    if ((id >= tm->first) && (id < tm->last)) return tm;
    else tm = tm->next;
  }
  return tm;
}

// ------------------------------------------------------------------------
// TypeMap *typemap_search_array(char *op, char *lang, DataType *type, char *pname, String &str)
//
// Performs a typemap lookup on an array type.  This is abit complicated
// because we need to look for ANY tags specifying that any array dimension
// is valid.   The resulting code will be placed in str with dimension variables
// substituted.
// ------------------------------------------------------------------------

TypeMap *typemap_search_array(char *op, char *lang, DataType *type, char *pname, String &str) {
  char      *origarr = type->arraystr;
  char      *key;
  int       ndim,i,j,k,n;
  TypeMap   *tm;
  char      temp[10];

  if (!type->arraystr) return 0;

  // First check to see if exactly this array has been mapped

  key = typemap_string(lang,type,pname,type->arraystr,op);
  tm = typemap_search(key,type->id);

  // Check for unnamed array of specific dimensions
  if (!tm) {
    key = typemap_string(lang,type,"",type->arraystr,op);
    tm = typemap_search(key,type->id);
  } 

  if (!tm) {
    // We're going to go search for matches with the ANY tag
    String  tempastr;
    ndim = type->array_dimensions();             // Get number of dimensions
    j = (1 << ndim) - 1;                         // Status bits
    for (i = 0; i < (1 << ndim); i++) {
      // Form an array string
      tempastr = "";
      k = j;
      for (n = 0; n < ndim; n++) {
	if (k & 1) {
	  tempastr << "[" << type->get_dimension(n) << "]";
	} else {
	  tempastr << "[ANY]";
	}
	k = k >> 1;
      }
      //      printf("checking (%s) : %s\n",origarr,tempastr.get());
      type->arraystr = tempastr.get();
      key = typemap_string(lang,type,pname,type->arraystr,op);
      tm = typemap_search(key,type->id);
      if (!tm) {
	key = typemap_string(lang,type,"",type->arraystr,op);
	tm = typemap_search(key,type->id);
      }
      type->arraystr = origarr;
      if (tm) break;
      j--;
    }
  }      
	
  if (tm) {
    str << tm->code;
    ndim = type->array_dimensions();
    for (i = 0; i < ndim; i++) {
      sprintf(temp,"$dim%d",i);
      str.replace(temp,type->get_dimension(i));
    }
  }
  return tm;
}

// ------------------------------------------------------------------------
// static typemap_locals(Datatype *t, char *pname, String &s, ParmList *l, WrapperFunction &f)
//
// Takes a string, a parameter list and a wrapper function argument and
// starts creating local variables.
//
// Substitutes locals in the string with actual values used.
// ------------------------------------------------------------------------

static void typemap_locals(DataType *t, char *pname, String &s, ParmList *l, WrapperFunction &f) {
  Parm *p;
  char *new_name;
  
  p = l->get_first();
  while (p) {
    if (p->name) {
      if (strlen(p->name) > 0) {
	String str;
	DataType *tt;

	// If the user gave us $type as the name of the local variable, we'll use
	// the passed datatype instead

	if (strcmp(p->t->name,"$type")==0 || strcmp(p->t->name,"$basetype")==0) {
	  tt = t;
	} else {
	  tt = p->t;
	}
        
	// Have a real parameter here
        if (tt->arraystr) {
	  tt->is_pointer--;
	  str << p->name << tt->arraystr;
	} 
        else {
	  str << p->name;
	}

	// Substitute parameter names
        str.replace("$arg",pname);
        if (strcmp(p->t->name,"$basetype")==0) {
          // use $basetype
          char temp_ip = tt->is_pointer;
          char temp_ip1 = tt->implicit_ptr;
          tt->is_pointer = 0;
          tt->implicit_ptr = 0;
          new_name = f.new_local(tt->print_type(),str);
          tt->is_pointer = temp_ip;
          tt->implicit_ptr = temp_ip1;
        } 
        else 
          new_name = f.new_local(tt->print_full(),str);

	if (tt->arraystr) tt->is_pointer++;
	// Substitute 
	s.replaceid(p->name,new_name);
      }
    }
    p = l->get_next();
  }
  // If the original datatype was an array. We're going to go through and substitute
  // it's array dimensions

  if (t->arraystr) {
    char temp[10];
    for (int i = 0; i < t->array_dimensions(); i++) {
      sprintf(temp,"$dim%d",i);
      f.locals.replace(temp,t->get_dimension(i));
    }
  }

}

// ------------------------------------------------------------------------
// char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *source,
//                      char *target, WrapperFunction *f)
//            
// Looks up a "get" function in the type-map and returns a character string
// containing the appropriate translation code.
//
// op       is string code for type of mapping
// lang     is the target language string
// type     is the datatype
// pname    is an optional parameter name
// source   is a string with the source variable
// target   is a string containing the target value
// f        is a wrapper function object (optional)
//
// Returns NULL if no mapping is found.
//
// Typemaps follow a few rules regarding naming and C pointers by checking
// declarations in this order.
//
//         1.   type name []         - A named array (most specific)
//         2.   type name            - Named argument
//         3.   type []              - Type with array
//         4.   type                 - Ordinary type
// 
// Array checking is only made if the datatype actally has an array specifier      
// 
// Array checking uses a special token "ANY" that indicates that any
// dimension will match.  Since we are passed a real datatype here, we
// need to hack this a special case.
//
// Array dimensions are substituted into the variables $dim1, $dim2,...,$dim9
// ------------------------------------------------------------------------

static DataType *realtype;       // This is a gross hack
static char     *realname = 0;   // Real parameter name

char *typemap_lookup_internal(char *op, char *lang, DataType *type, char *pname, char *source,
                     char *target, WrapperFunction *f) {
  static String str;
  char *key = 0;
  TypeMap *tm = 0;

  if (!lang) {
    return 0;
  }

  // First check for named array
  str = "";
  tm = typemap_search_array(op,lang,type,pname,str);

  // Check for named argument
  if (!tm) {
    key = typemap_string(lang,type,pname,0,op);
    tm = typemap_search(key,type->id);
    if (tm)
      str << tm->code;
  }

  // Check for unnamed type
  if (!tm) {
    key = typemap_string(lang,type,"",0,op);
    tm = typemap_search(key,type->id);
    if (tm)
      str << tm->code;
  }
  if (!tm) return 0;
  
  // Now perform character replacements

  str.replace("$source",source);
  str.replace("$target",target);
  str.replace("$type", realtype->print_type());
  if (realname) {
    str.replace("$parmname", realname);
  } else {
    str.replace("$parmname","");
  }
  // Print base type (without any pointers)
  {
    char temp_ip = realtype->is_pointer;
    char temp_ip1 = realtype->implicit_ptr;
    realtype->is_pointer = 0;
    realtype->implicit_ptr = 0;
    char *bt = realtype->print_type();
    if (bt[strlen(bt)-1] == ' ') 
      bt[strlen(bt)-1] = 0;
    str.replace("$basetype",bt);
    str.replace("$basemangle",realtype->print_mangle());
    realtype->is_pointer = temp_ip;
    realtype->implicit_ptr = temp_ip1;
  }
  
  str.replace("$mangle",realtype->print_mangle());

  // If there were locals and a wrapper function, replace
  if ((tm->args) && f) {
    typemap_locals(realtype, pname, str,tm->args,*f);
  }

  // If there were locals and no wrapper function, print a warning
  if ((tm->args) && !f) {
    if (!pname) pname = "";
    fprintf(stderr,"%s:%d: Warning. '%%typemap(%s,%s) %s %s' being applied with ignored locals.\n",
	    input_file, line_number, lang,op, type->print_type(), pname);
  }

  // Return character string

  return str;
}

// ----------------------------------------------------------
// Real function call that takes care of application mappings
// ----------------------------------------------------------

char *typemap_lookup(char *op, char *lang, DataType *type, char *pname, char *source,
                     char *target, WrapperFunction *f) {
  TmMethod *m;
  char temp[512];
  char *result;
  char *ppname;
  char *tstr;

  realtype = type;         // The other half of the gross hack
  realname = pname;

  // Try to apply typemap right away

  result = typemap_lookup_internal(op,lang,type,pname,source,target,f);

  // If not found, try to pick up anything that might have been
  // specified with %apply

  if ((!result) && (pname)) {
    int drop_pointer = 0;
    ppname = pname;
    if (!ppname) ppname = "";
    
    // The idea : We're going to cycle through applications and
    // drop pointers off until we get a match.   

    while (drop_pointer <= (type->is_pointer - type->implicit_ptr)) {
      type->is_pointer -= drop_pointer;
      tstr = type->print_type();
      sprintf(temp,"%s$%s",tstr,ppname);
      // No mapping was found.  See if the name has been mapped with %apply
      m = (TmMethod *) application_hash.lookup(temp);
      if (!m) {
	sprintf(temp,"%s$",tstr);
	m = (TmMethod *) application_hash.lookup(temp);
      }
      if (m) {
	m = m->next;
	while (m) {
	  char *oldary = 0;
	  static String newarray;
	  if (*(m->name)) ppname = m->name;
	  else ppname = pname;
	  m->type->is_pointer += drop_pointer;

	  // Copy old array string (just in case)

	  oldary = m->type->arraystr; 

	  // If the mapping type is an array and has the 'ANY' keyword, we
          // have to play some magic

	  if ((m->type->arraystr) && (type->arraystr)) {
	    // Build up the new array string
	    newarray = "";
	    for (int n = 0; n < m->type->array_dimensions(); n++) {
	      char *d = m->type->get_dimension(n);
	      if (strcmp(d,"ANY") == 0) {
		newarray << "[" << type->get_dimension(n) << "]";
	      } else {
		newarray << "[" << d << "]";
	      }
	    }
	    m->type->arraystr = newarray.get();
	  } else if (type->arraystr) {
	    // If an array string is available for the current datatype,
	    // make it available.
	    m->type->arraystr = type->arraystr;
	  }
	  result = typemap_lookup_internal(op,lang,m->type,ppname,source,target,f);
	  m->type->arraystr = oldary;
	  m->type->is_pointer -= drop_pointer;
	  if (result) {
	    type->is_pointer += drop_pointer;
	    return result;
	  }
	  m = m->next;
	}
      }
      type->is_pointer += drop_pointer;
      drop_pointer++;
    }
  }
  // Still no idea, try to find a default typemap

  if (!result) {
    DataType *t = new DataType(type);
    t->primitive(); // Knock it down to its basic type
    result = typemap_lookup_internal(op,lang,t,"SWIG_DEFAULT_TYPE",source,target,f);
    if (result) {
      delete t;
      return result;
    }
    if ((t->type == T_USER) || (t->is_pointer)) {
      if ((t->type == T_CHAR) && (t->is_pointer == 1)) return 0;
    
      // Still no result, go even more primitive
      t->type = T_USER;
      t->is_pointer = 1;
      if (t->arraystr) delete [] t->arraystr;
      t->arraystr = 0;
      t->primitive();
      result = typemap_lookup_internal(op,lang,t,"SWIG_DEFAULT_TYPE",source,target,f);
    }
    delete t;
  }
  return result;
}

// ----------------------------------------------------------------------------
// char *typemap_check(char *op, char *lang, DataType *type, char *pname)
//
// Checks to see if there is a typemap.  Returns typemap string if found, NULL
// if not.
// ----------------------------------------------------------------------------

char *typemap_check_internal(char *op, char *lang, DataType *type, char *pname) {
  static String str;
  char *key = 0;
  TypeMap *tm = 0;

  if (!lang) {
    return 0;
  }
  // First check for named array
  str = "";
  tm = typemap_search_array(op,lang,type,pname,str);

  // First check for named array
  //
  //  if (type->arraystr) {
  //    key = typemap_string(lang,type,pname,type->arraystr,op);
  //    tm = typemap_search(key,type->id);
  //  }

  // Check for named argument
  if (!tm) {
    key = typemap_string(lang,type,pname,0,op);
    tm = typemap_search(key,type->id);
  }

  // Check for unnamed array
  if ((!tm) && (type->arraystr)) {
    key = typemap_string(lang,type,"",type->arraystr,op);
    tm = typemap_search(key,type->id);
  } 

  // Check for unname type
  if (!tm) {
    key = typemap_string(lang,type,"",0,op);
    tm = typemap_search(key,type->id);
  }
  if (!tm) return 0;
  
  str = "";
  str << tm->code;

  // Return character string

  return str;
}

// Function for checking with applications

char *typemap_check(char *op, char *lang, DataType *type, char *pname) {
  TmMethod *m;
  char temp[512];
  char *result;
  char *ppname;
  char *tstr;
  // Try to apply typemap right away

  result = typemap_check_internal(op,lang,type,pname);

  if (!result) {
    int drop_pointer = 0;
    ppname = pname;
    if (!ppname) ppname = "";
    
    // The idea : We're going to cycle through applications and
    // drop pointers off until we get a match.   

    while (drop_pointer <= (type->is_pointer - type->implicit_ptr)) {
      type->is_pointer -= drop_pointer;
      tstr = type->print_type();
      sprintf(temp,"%s$%s",tstr,ppname);
      // No mapping was found.  See if the name has been mapped with %apply
      m = (TmMethod *) application_hash.lookup(temp);
      if (!m) {
	sprintf(temp,"%s$",tstr);
	m = (TmMethod *) application_hash.lookup(temp);
      }
      if (m) {
	m = m->next;
	while (m) {
	  char *oldary = 0;
	  static String newarray;
	  if (*(m->name)) ppname = m->name;
	  else ppname = pname;
	  m->type->is_pointer += drop_pointer;
	  oldary = m->type->arraystr;

	  // If the mapping type is an array and has the 'ANY' keyword, we
          // have to play some magic
	  
	  if ((m->type->arraystr) && (type->arraystr)) {
	    // Build up the new array string
	    newarray = "";
	    for (int n = 0; n < m->type->array_dimensions(); n++) {
	      char *d = m->type->get_dimension(n);
	      if (strcmp(d,"ANY") == 0) {
		newarray << "[" << type->get_dimension(n) << "]";
	      } else {
		newarray << "[" << d << "]";
	      }
	    }
	    oldary = m->type->arraystr;
	    m->type->arraystr = newarray.get();
	  } else if (type->arraystr) {
	    m->type->arraystr = type->arraystr;
	  }
	  result = typemap_check_internal(op,lang,m->type,ppname);
	  m->type->arraystr = oldary;
	  m->type->is_pointer -= drop_pointer;
	  if (result) {
	    type->is_pointer += drop_pointer;
	    return result;
	  }
	  m = m->next;
	}
      }
      type->is_pointer += drop_pointer;
      drop_pointer++;
    }
  }

  // If still no result, might have a default typemap
  if (!result) {
    DataType *t = new DataType(type);
    t->primitive(); // Knock it down to its basic type
    result = typemap_check_internal(op,lang,t,"SWIG_DEFAULT_TYPE");
    if (result) {
      delete t;
      return result;
    }
    if ((t->type == T_USER) || (t->is_pointer)) {
      if ((t->type == T_CHAR) && (t->is_pointer == 1)) return 0;
      // Still no result, go even more primitive
      t->type = T_USER;
      t->is_pointer = 1;
      if (t->arraystr) delete [] t->arraystr;
      t->arraystr = 0;
      t->primitive();
      result = typemap_check_internal(op,lang,t,"SWIG_DEFAULT_TYPE");
    }
    delete t;
  }
  return result;
}

// ------------------------------------------------------------------------
// void typemap_clear(char *op, char *lang, DataType *type, char *pname)
//
// Clears any previous typemap.   This works like a stack.  Clearing a
// typemap returns to any previous typemap in force.   If there is no
// previous map, then don't worry about it.
// ------------------------------------------------------------------------

void typemap_clear(char *op, char *lang, DataType *type, char *pname) {
  
  char     *key;
  TypeMap  *tm;

  key = typemap_string(lang,type,pname,type->arraystr,op);

  // Look for any previous version, simply set the last id if
  // applicable.
  
  tm = (TypeMap *) typemap_hash.lookup(key);
  if (tm) {
    if (tm->last > type_id) tm->last = type_id;
  }
}

// ------------------------------------------------------------------------
// void typemap_copy(char *op, char *lang, DataType *stype, char *sname,
//                   DataType *ttype, char *tname)
//
// Copies the code associate with a typemap
// ------------------------------------------------------------------------

void typemap_copy(char *op, char *lang, DataType *stype, char *sname,
		      DataType *ttype, char *tname) {
  
  char     *key;
  TypeMap  *tm, *tk, *tn;

  // Try to locate a previous typemap

  key = typemap_string(lang,stype,sname,stype->arraystr,op);
  tm = typemap_search(key,stype->id);
  if (!tm) return;
  if (strcmp(ttype->name,"PREVIOUS") == 0) {
    // Pop back up to the previous typemap (if any)
    tk = tm->next;
    if (tk) {
      tn = new TypeMap(tk);       // Make a copy of the previous typemap
      tn->next = tm;              // Set up symlinks
      typemap_hash.remove(key);   // Remove old hash entry
      typemap_hash.add(key,(void *) tn);
    }
  } else {
    typemap_register(op,lang,ttype,tname,tm->code,tm->args);
  }
}

// ------------------------------------------------------------------------
// char *fragment_string(char *op, char *lang)
//
// Produces a character string corresponding to a language and method
// This string is used as the key for our typemap hash table.
// ------------------------------------------------------------------------

static char *fragment_string(char *op, char *lang) {
  static String str;

  str = "";

  str << "fragment:" << lang << op;
  return str;
}

// ------------------------------------------------------------------------
// void fragment_register(char *op, char *lang, char *code)
//
// Register a code fragment with the type-mapper.
// ------------------------------------------------------------------------

void fragment_register(char *op, char *lang, char *code) {
  
  char     *key;
  TypeMap  *tm,*tm_old;
  char      temp[256];
  
  tm = new TypeMap(lang,code);
  key = fragment_string(op,lang);

  // Get any previous setting of the typemap

  tm_old = (TypeMap *) typemap_hash.lookup(key);
  if (tm_old) {
    // If found, we need to attach the old version to the new one

    // Perform a chaining operation 

    sprintf(temp,"$%s",op);
    if (type_id < tm_old->last)
      tm->code.replace(temp,tm_old->code);

    tm->next = tm_old;
    tm_old->last = type_id;

    // Remove the old one from the hash
  
    typemap_hash.remove(key);
  }
  
  // Perform a default chaining operation if needed (defaults to nothing)
  sprintf(temp,"$%s",op);
  tm->code.replace(temp,"");

  // Add new typemap to the hash table
  typemap_hash.add(key,(void *) tm);
    
}


// ------------------------------------------------------------------------
// char *fragment_lookup(char *op, char *lang, int age)
//
// op       is string code for type of mapping
// lang     is the target language string
// age      is age of fragment.
//
// Returns NULL if no mapping is found.
//
// ------------------------------------------------------------------------

char *fragment_lookup(char *op, char *lang, int age) {
  static String str;
  char *key = 0;
  TypeMap *tm = 0;

  if (!lang) {
    return 0;
  }

  str = "";
  key = fragment_string(op,lang);
  tm = typemap_search(key,age);

  if (!tm) return 0;

  str << tm->code;
  return str;
}

// ------------------------------------------------------------------------
// void fragment_clear(char *op, char *lang)
//
// Clears any previous fragment definition.   Is a stack operation--will
// restore any previously declared typemap.
// ------------------------------------------------------------------------

void fragment_clear(char *op, char *lang) {
  
  char     *key;
  TypeMap  *tm;

  key = fragment_string(op,lang);

  // Look for any previous version, simply set the last id if
  // applicable.
  
  tm = (TypeMap *) typemap_hash.lookup(key);
  if (tm) {
    if (tm->last > type_id) tm->last = type_id;
  }
}