wxPython/src/libpy.c

/***********************************************************************
 * $Header$
 * swig_lib/python/python.cfg
 *
 * Contains variable linking and pointer type-checking code.
 ************************************************************************/

#include <string.h>
#include <stdlib.h>

#include "Python.h"

#ifdef __cplusplus
extern "C" {
#endif

/* Definitions for Windows/Unix exporting */
#if defined(_WIN32) || defined(__WIN32__)
#   if defined(_MSC_VER)
#	define SWIGEXPORT(a) __declspec(dllexport) a
#   else
#	if defined(__BORLANDC__)
#	    define SWIGEXPORT(a) a _export
#	else
#	    define SWIGEXPORT(a) a
#	endif
#   endif
#else
#   define SWIGEXPORT(a) a
#endif

#ifdef SWIG_GLOBAL
#define SWIGSTATICRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGSTATICRUNTIME(a) static a
#endif

typedef struct {
  char  *name;
  PyObject *(*get_attr)(void);
  int (*set_attr)(PyObject *);
} swig_globalvar;

typedef struct swig_varlinkobject {
  PyObject_HEAD
  swig_globalvar **vars;
  int      nvars;
  int      maxvars;
} swig_varlinkobject;

/* ----------------------------------------------------------------------
   swig_varlink_repr()

   Function for python repr method
   ---------------------------------------------------------------------- */

static PyObject *
swig_varlink_repr(swig_varlinkobject *v)
{
  v = v;
  return PyString_FromString("<Global variables>");
}

/* ---------------------------------------------------------------------
   swig_varlink_print()

   Print out all of the global variable names
   --------------------------------------------------------------------- */

static int
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags)
{

  int i = 0;
  flags = flags;
  fprintf(fp,"Global variables { ");
  while (v->vars[i]) {
    fprintf(fp,"%s", v->vars[i]->name);
    i++;
    if (v->vars[i]) fprintf(fp,", ");
  }
  fprintf(fp," }\n");
  return 0;
}

/* --------------------------------------------------------------------
   swig_varlink_getattr

   This function gets the value of a variable and returns it as a
   PyObject.   In our case, we'll be looking at the datatype and
   converting into a number or string
   -------------------------------------------------------------------- */

static PyObject *
swig_varlink_getattr(swig_varlinkobject *v, char *n)
{
  int i = 0;
  char temp[128];

  while (v->vars[i]) {
    if (strcmp(v->vars[i]->name,n) == 0) {
      return (*v->vars[i]->get_attr)();
    }
    i++;
  }
  sprintf(temp,"C global variable %s not found.", n);
  PyErr_SetString(PyExc_NameError,temp);
  return NULL;
}

/* -------------------------------------------------------------------
   swig_varlink_setattr()

   This function sets the value of a variable.
   ------------------------------------------------------------------- */

static int
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p)
{
  char temp[128];
  int i = 0;
  while (v->vars[i]) {
    if (strcmp(v->vars[i]->name,n) == 0) {
      return (*v->vars[i]->set_attr)(p);
    }
    i++;
  }
  sprintf(temp,"C global variable %s not found.", n);
  PyErr_SetString(PyExc_NameError,temp);
  return 1;
}

statichere PyTypeObject varlinktype = {
/*  PyObject_HEAD_INIT(&PyType_Type)  Note : This doesn't work on some machines */
  PyObject_HEAD_INIT(0)
  0,
  "varlink",                          /* Type name    */
  sizeof(swig_varlinkobject),         /* Basic size   */
  0,                                  /* Itemsize     */
  0,                                  /* Deallocator  */
  (printfunc) swig_varlink_print,     /* Print        */
  (getattrfunc) swig_varlink_getattr, /* get attr     */
  (setattrfunc) swig_varlink_setattr, /* Set attr     */
  0,                                  /* tp_compare   */
  (reprfunc) swig_varlink_repr,       /* tp_repr      */
  0,                                  /* tp_as_number */
  0,                                  /* tp_as_mapping*/
  0,                                  /* tp_hash      */
};

/* Create a variable linking object for use later */

SWIGSTATICRUNTIME(PyObject *)
SWIG_newvarlink(void)
{
  swig_varlinkobject *result = 0;
  result = PyMem_NEW(swig_varlinkobject,1);
  varlinktype.ob_type = &PyType_Type;    /* Patch varlinktype into a PyType */
  result->ob_type = &varlinktype;
  /*  _Py_NewReference(result);  Does not seem to be necessary */
  result->nvars = 0;
  result->maxvars = 64;
  result->vars = (swig_globalvar **) malloc(64*sizeof(swig_globalvar *));
  result->vars[0] = 0;
  result->ob_refcnt = 0;
  Py_XINCREF((PyObject *) result);
  return ((PyObject*) result);
}

SWIGSTATICRUNTIME(void)
SWIG_addvarlink(PyObject *p, char *name,
	   PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p))
{
  swig_varlinkobject *v;
  v= (swig_varlinkobject *) p;

  if (v->nvars >= v->maxvars -1) {
    v->maxvars = 2*v->maxvars;
    v->vars = (swig_globalvar **) realloc(v->vars,v->maxvars*sizeof(swig_globalvar *));
    if (v->vars == NULL) {
      fprintf(stderr,"SWIG : Fatal error in initializing Python module.\n");
      exit(1);
    }
  }
  v->vars[v->nvars] = (swig_globalvar *) malloc(sizeof(swig_globalvar));
  v->vars[v->nvars]->name = (char *) malloc(strlen(name)+1);
  strcpy(v->vars[v->nvars]->name,name);
  v->vars[v->nvars]->get_attr = get_attr;
  v->vars[v->nvars]->set_attr = set_attr;
  v->nvars++;
  v->vars[v->nvars] = 0;
}

/* -----------------------------------------------------------------------------
 * Pointer type-checking
 * ----------------------------------------------------------------------------- */

/* SWIG pointer structure */
typedef struct SwigPtrType {
  char               *name;               /* Datatype name                  */
  int                 len;                /* Length (used for optimization) */
  void               *(*cast)(void *);    /* Pointer casting function       */
  struct SwigPtrType *next;               /* Linked list pointer            */
} SwigPtrType;

/* Pointer cache structure */
typedef struct {
  int                 stat;               /* Status (valid) bit             */
  SwigPtrType        *tp;                 /* Pointer to type structure      */
  char                name[256];          /* Given datatype name            */
  char                mapped[256];        /* Equivalent name                */
} SwigCacheType;

static int SwigPtrMax  = 64;           /* Max entries that can be currently held */
static int SwigPtrN    = 0;            /* Current number of entries              */
static int SwigPtrSort = 0;            /* Status flag indicating sort            */
static int SwigStart[256];             /* Starting positions of types            */
static SwigPtrType *SwigPtrTable = 0;  /* Table containing pointer equivalences  */

/* Cached values */
#define SWIG_CACHESIZE  8
#define SWIG_CACHEMASK  0x7
static SwigCacheType SwigCache[SWIG_CACHESIZE];
static int SwigCacheIndex = 0;
static int SwigLastCache = 0;

/* Sort comparison function */
static int swigsort(const void *data1, const void *data2) {
	SwigPtrType *d1 = (SwigPtrType *) data1;
	SwigPtrType *d2 = (SwigPtrType *) data2;
	return strcmp(d1->name,d2->name);
}

/* Register a new datatype with the type-checker */
SWIGSTATICRUNTIME(void)
SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) {
  int i;
  SwigPtrType *t = 0,*t1;

  /* Allocate the pointer table if necessary */
  if (!SwigPtrTable) {
    SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType));
  }

  /* Grow the table */
  if (SwigPtrN >= SwigPtrMax) {
    SwigPtrMax = 2*SwigPtrMax;
    SwigPtrTable = (SwigPtrType *) realloc((char *) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
  }
  for (i = 0; i < SwigPtrN; i++) {
    if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
      t = &SwigPtrTable[i];
      break;
    }
  }
  if (!t) {
    t = &SwigPtrTable[SwigPtrN++];
    t->name = origtype;
    t->len = strlen(t->name);
    t->cast = 0;
    t->next = 0;
  }

  /* Check for existing entries */
  while (t->next) {
    if ((strcmp(t->name,newtype) == 0)) {
      if (cast) t->cast = cast;
      return;
    }
    t = t->next;
  }
  t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
  t1->name = newtype;
  t1->len = strlen(t1->name);
  t1->cast = cast;
  t1->next = 0;
  t->next = t1;
  SwigPtrSort = 0;
}

/* Make a pointer value string */
SWIGSTATICRUNTIME(void)
SWIG_MakePtr(char *c, const void *ptr, char *type) {
  static char hex[17] = "0123456789abcdef";
  unsigned long p, s;
  char result[24], *r;
  r = result;
  p = (unsigned long) ptr;
  if (p > 0) {
    while (p > 0) {
      s = p & 0xf;
      *(r++) = hex[s];
      p = p >> 4;
    }
    *r = '_';
    while (r >= result)
      *(c++) = *(r--);
    strcpy (c, type);
  } else {
    strcpy (c, "NULL");
  }
}

/* Function for getting a pointer value */
SWIGSTATICRUNTIME(char *)
SWIG_GetPtr(char *c, void **ptr, char *t)
{
  unsigned long p;
  char temp_type[256], *name;
  int  i, len, start, end;
  SwigPtrType *sp,*tp;
  SwigCacheType *cache;
  register int d;

  p = 0;
  /* Pointer values must start with leading underscore */
  if (*c != '_') {
    *ptr = (void *) 0;
    if (strcmp(c,"NULL") == 0) return (char *) 0;
    else c;
  }
  c++;
  /* Extract hex value from pointer */
  while (d = *c) {
    if ((d >= '0') && (d <= '9'))
      p = (p << 4) + (d - '0');
    else if ((d >= 'a') && (d <= 'f'))
      p = (p << 4) + (d - ('a'-10));
    else
      break;
    c++;
  }
  *ptr = (void *) p;
  if ((!t) || (strcmp(t,c)==0)) return (char *) 0;

  if (!SwigPtrSort) {
    qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
    for (i = 0; i < 256; i++) SwigStart[i] = SwigPtrN;
    for (i = SwigPtrN-1; i >= 0; i--) SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
    for (i = 255; i >= 1; i--) {
      if (SwigStart[i-1] > SwigStart[i])
	SwigStart[i-1] = SwigStart[i];
    }
    SwigPtrSort = 1;
    for (i = 0; i < SWIG_CACHESIZE; i++) SwigCache[i].stat = 0;
  }
  /* First check cache for matches.  Uses last cache value as starting point */
  cache = &SwigCache[SwigLastCache];
  for (i = 0; i < SWIG_CACHESIZE; i++) {
    if (cache->stat && (strcmp(t,cache->name) == 0) && (strcmp(c,cache->mapped) == 0)) {
      cache->stat++;
      if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
      return (char *) 0;
    }
    SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
    if (!SwigLastCache) cache = SwigCache;
    else cache++;
  }
  /* Type mismatch.  Look through type-mapping table */
  start = SwigStart[(int) t[1]];
  end = SwigStart[(int) t[1]+1];
  sp = &SwigPtrTable[start];

  /* Try to find a match */
  while (start <= end) {
    if (strncmp(t,sp->name,sp->len) == 0) {
      name = sp->name;
      len = sp->len;
      tp = sp->next;
      /* Try to find entry for our given datatype */
      while(tp) {
	if (tp->len >= 255) {
	  return c;
	}
	strcpy(temp_type,tp->name);
	strncat(temp_type,t+len,255-tp->len);
	if (strcmp(c,temp_type) == 0) {
	  strcpy(SwigCache[SwigCacheIndex].mapped,c);
	  strcpy(SwigCache[SwigCacheIndex].name,t);
	  SwigCache[SwigCacheIndex].stat = 1;
	  SwigCache[SwigCacheIndex].tp = tp;
	  SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
	  /* Get pointer value */
	  *ptr = (void *) p;
	  if (tp->cast) *ptr = (*(tp->cast))(*ptr);
	  return (char *) 0;
	}
	tp = tp->next;
      }
    }
    sp++;
    start++;
  }
  return c;
}

/* New object-based GetPointer function. This uses the Python abstract
 * object interface to automatically dereference the 'this' attribute
 * of shadow objects. */

SWIGSTATICRUNTIME(char *)
SWIG_GetPtrObj(PyObject *obj, void **ptr, char *type) {
  PyObject *sobj = obj;
  char     *str;
  if (!PyString_Check(obj)) {
      if (!PyInstance_Check(obj) || !(sobj = PyObject_GetAttrString(obj,"this")))
          return "";
      // PyObject_GetAttrString increases sobj refcout !
      Py_DECREF(sobj);
  }
  str = PyString_AsString(sobj);
  return SWIG_GetPtr(str,ptr,type);
}


#ifdef __cplusplus
}
#endif
Commit	Line	Data
	1	/***********************************************************************
	2	* $Header$
	3	* swig_lib/python/python.cfg
	4	*
	5	* Contains variable linking and pointer type-checking code.
	6	************************************************************************/
	7
	8	#include <string.h>
	9	#include <stdlib.h>
	10
	11	#include "Python.h"
	12
	13	#ifdef __cplusplus
	14	extern "C" {
	15	#endif
	16
	17	/* Definitions for Windows/Unix exporting */
	18	#if defined(_WIN32) \|\| defined(__WIN32__)
	19	# if defined(_MSC_VER)
	20	# define SWIGEXPORT(a) __declspec(dllexport) a
	21	# else
	22	# if defined(__BORLANDC__)
	23	# define SWIGEXPORT(a) a _export
	24	# else
	25	# define SWIGEXPORT(a) a
	26	# endif
	27	# endif
	28	#else
	29	# define SWIGEXPORT(a) a
	30	#endif
	31
	32	#ifdef SWIG_GLOBAL
	33	#define SWIGSTATICRUNTIME(a) SWIGEXPORT(a)
	34	#else
	35	#define SWIGSTATICRUNTIME(a) static a
	36	#endif
	37
	38	typedef struct {
	39	char *name;
	40	PyObject (get_attr)(void);
	41	int (set_attr)(PyObject );
	42	} swig_globalvar;
	43
	44	typedef struct swig_varlinkobject {
	45	PyObject_HEAD
	46	swig_globalvar **vars;
	47	int nvars;
	48	int maxvars;
	49	} swig_varlinkobject;
	50
	51	/* ----------------------------------------------------------------------
	52	swig_varlink_repr()
	53
	54	Function for python repr method
	55	---------------------------------------------------------------------- */
	56
	57	static PyObject *
	58	swig_varlink_repr(swig_varlinkobject *v)
	59	{
	60	v = v;
	61	return PyString_FromString("<Global variables>");
	62	}
	63
	64	/* ---------------------------------------------------------------------
	65	swig_varlink_print()
	66
	67	Print out all of the global variable names
	68	--------------------------------------------------------------------- */
	69
	70	static int
	71	swig_varlink_print(swig_varlinkobject v, FILE fp, int flags)
	72	{
	73
	74	int i = 0;
	75	flags = flags;
	76	fprintf(fp,"Global variables { ");
	77	while (v->vars[i]) {
	78	fprintf(fp,"%s", v->vars[i]->name);
	79	i++;
	80	if (v->vars[i]) fprintf(fp,", ");
	81	}
	82	fprintf(fp," }\n");
	83	return 0;
	84	}
	85
	86	/* --------------------------------------------------------------------
	87	swig_varlink_getattr
	88
	89	This function gets the value of a variable and returns it as a
	90	PyObject. In our case, we'll be looking at the datatype and
	91	converting into a number or string
	92	-------------------------------------------------------------------- */
	93
	94	static PyObject *
	95	swig_varlink_getattr(swig_varlinkobject v, char n)
	96	{
	97	int i = 0;
	98	char temp[128];
	99
	100	while (v->vars[i]) {
	101	if (strcmp(v->vars[i]->name,n) == 0) {
	102	return (*v->vars[i]->get_attr)();
	103	}
	104	i++;
	105	}
	106	sprintf(temp,"C global variable %s not found.", n);
	107	PyErr_SetString(PyExc_NameError,temp);
	108	return NULL;
	109	}
	110
	111	/* -------------------------------------------------------------------
	112	swig_varlink_setattr()
	113
	114	This function sets the value of a variable.
	115	------------------------------------------------------------------- */
	116
	117	static int
	118	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p)
	119	{
	120	char temp[128];
	121	int i = 0;
	122	while (v->vars[i]) {
	123	if (strcmp(v->vars[i]->name,n) == 0) {
	124	return (*v->vars[i]->set_attr)(p);
	125	}
	126	i++;
	127	}
	128	sprintf(temp,"C global variable %s not found.", n);
	129	PyErr_SetString(PyExc_NameError,temp);
	130	return 1;
	131	}
	132
	133	statichere PyTypeObject varlinktype = {
	134	/* PyObject_HEAD_INIT(&PyType_Type) Note : This doesn't work on some machines */
	135	PyObject_HEAD_INIT(0)
	136	0,
	137	"varlink", /* Type name */
	138	sizeof(swig_varlinkobject), /* Basic size */
	139	0, /* Itemsize */
	140	0, /* Deallocator */
	141	(printfunc) swig_varlink_print, /* Print */
	142	(getattrfunc) swig_varlink_getattr, /* get attr */
	143	(setattrfunc) swig_varlink_setattr, /* Set attr */
	144	0, /* tp_compare */
	145	(reprfunc) swig_varlink_repr, /* tp_repr */
	146	0, /* tp_as_number */
	147	0, /* tp_as_mapping*/
	148	0, /* tp_hash */
	149	};
	150
	151	/* Create a variable linking object for use later */
	152
	153	SWIGSTATICRUNTIME(PyObject *)
	154	SWIG_newvarlink(void)
	155	{
	156	swig_varlinkobject *result = 0;
	157	result = PyMem_NEW(swig_varlinkobject,1);
	158	varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
	159	result->ob_type = &varlinktype;
	160	/* _Py_NewReference(result); Does not seem to be necessary */
	161	result->nvars = 0;
	162	result->maxvars = 64;
	163	result->vars = (swig_globalvar *) malloc(64sizeof(swig_globalvar *));
	164	result->vars[0] = 0;
	165	result->ob_refcnt = 0;
	166	Py_XINCREF((PyObject *) result);
	167	return ((PyObject*) result);
	168	}
	169
	170	SWIGSTATICRUNTIME(void)
	171	SWIG_addvarlink(PyObject p, char name,
	172	PyObject (get_attr)(void), int (set_attr)(PyObject p))
	173	{
	174	swig_varlinkobject *v;
	175	v= (swig_varlinkobject *) p;
	176
	177	if (v->nvars >= v->maxvars -1) {
	178	v->maxvars = 2*v->maxvars;
	179	v->vars = (swig_globalvar *) realloc(v->vars,v->maxvarssizeof(swig_globalvar *));
	180	if (v->vars == NULL) {
	181	fprintf(stderr,"SWIG : Fatal error in initializing Python module.\n");
	182	exit(1);
	183	}
	184	}
	185	v->vars[v->nvars] = (swig_globalvar *) malloc(sizeof(swig_globalvar));
	186	v->vars[v->nvars]->name = (char *) malloc(strlen(name)+1);
	187	strcpy(v->vars[v->nvars]->name,name);
	188	v->vars[v->nvars]->get_attr = get_attr;
	189	v->vars[v->nvars]->set_attr = set_attr;
	190	v->nvars++;
	191	v->vars[v->nvars] = 0;
	192	}
	193
	194	/* -----------------------------------------------------------------------------
	195	* Pointer type-checking
	196	* ----------------------------------------------------------------------------- */
	197
	198	/* SWIG pointer structure */
	199	typedef struct SwigPtrType {
	200	char name; / Datatype name */
	201	int len; /* Length (used for optimization) */
	202	void (cast)(void ); / Pointer casting function */
	203	struct SwigPtrType next; / Linked list pointer */
	204	} SwigPtrType;
	205
	206	/* Pointer cache structure */
	207	typedef struct {
	208	int stat; /* Status (valid) bit */
	209	SwigPtrType tp; / Pointer to type structure */
	210	char name[256]; /* Given datatype name */
	211	char mapped[256]; /* Equivalent name */
	212	} SwigCacheType;
	213
	214	static int SwigPtrMax = 64; /* Max entries that can be currently held */
	215	static int SwigPtrN = 0; /* Current number of entries */
	216	static int SwigPtrSort = 0; /* Status flag indicating sort */
	217	static int SwigStart[256]; /* Starting positions of types */
	218	static SwigPtrType SwigPtrTable = 0; / Table containing pointer equivalences */
	219
	220	/* Cached values */
	221	#define SWIG_CACHESIZE 8
	222	#define SWIG_CACHEMASK 0x7
	223	static SwigCacheType SwigCache[SWIG_CACHESIZE];
	224	static int SwigCacheIndex = 0;
	225	static int SwigLastCache = 0;
	226
	227	/* Sort comparison function */
	228	static int swigsort(const void data1, const void data2) {
	229	SwigPtrType d1 = (SwigPtrType ) data1;
	230	SwigPtrType d2 = (SwigPtrType ) data2;
	231	return strcmp(d1->name,d2->name);
	232	}
	233
	234	/* Register a new datatype with the type-checker */
	235	SWIGSTATICRUNTIME(void)
	236	SWIG_RegisterMapping(char origtype, char newtype, void (cast)(void *)) {
	237	int i;
	238	SwigPtrType t = 0,t1;
	239
	240	/* Allocate the pointer table if necessary */
	241	if (!SwigPtrTable) {
	242	SwigPtrTable = (SwigPtrType ) malloc(SwigPtrMaxsizeof(SwigPtrType));
	243	}
	244
	245	/* Grow the table */
	246	if (SwigPtrN >= SwigPtrMax) {
	247	SwigPtrMax = 2*SwigPtrMax;
	248	SwigPtrTable = (SwigPtrType ) realloc((char ) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
	249	}
	250	for (i = 0; i < SwigPtrN; i++) {
	251	if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
	252	t = &SwigPtrTable[i];
	253	break;
	254	}
	255	}
	256	if (!t) {
	257	t = &SwigPtrTable[SwigPtrN++];
	258	t->name = origtype;
	259	t->len = strlen(t->name);
	260	t->cast = 0;
	261	t->next = 0;
	262	}
	263
	264	/* Check for existing entries */
	265	while (t->next) {
	266	if ((strcmp(t->name,newtype) == 0)) {
	267	if (cast) t->cast = cast;
	268	return;
	269	}
	270	t = t->next;
	271	}
	272	t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
	273	t1->name = newtype;
	274	t1->len = strlen(t1->name);
	275	t1->cast = cast;
	276	t1->next = 0;
	277	t->next = t1;
	278	SwigPtrSort = 0;
	279	}
	280
	281	/* Make a pointer value string */
	282	SWIGSTATICRUNTIME(void)
	283	SWIG_MakePtr(char c, const void ptr, char *type) {
	284	static char hex[17] = "0123456789abcdef";
	285	unsigned long p, s;
	286	char result[24], *r;
	287	r = result;
	288	p = (unsigned long) ptr;
	289	if (p > 0) {
	290	while (p > 0) {
	291	s = p & 0xf;
	292	*(r++) = hex[s];
	293	p = p >> 4;
	294	}
	295	*r = '_';
	296	while (r >= result)
	297	(c++) = (r--);
	298	strcpy (c, type);
	299	} else {
	300	strcpy (c, "NULL");
	301	}
	302	}
	303
	304	/* Function for getting a pointer value */
	305	SWIGSTATICRUNTIME(char *)
	306	SWIG_GetPtr(char c, void ptr, char t)
	307	{
	308	unsigned long p;
	309	char temp_type[256], *name;
	310	int i, len, start, end;
	311	SwigPtrType sp,tp;
	312	SwigCacheType *cache;
	313	register int d;
	314
	315	p = 0;
	316	/* Pointer values must start with leading underscore */
	317	if (*c != '_') {
	318	ptr = (void ) 0;
	319	if (strcmp(c,"NULL") == 0) return (char *) 0;
	320	else c;
	321	}
	322	c++;
	323	/* Extract hex value from pointer */
	324	while (d = *c) {
	325	if ((d >= '0') && (d <= '9'))
	326	p = (p << 4) + (d - '0');
	327	else if ((d >= 'a') && (d <= 'f'))
	328	p = (p << 4) + (d - ('a'-10));
	329	else
	330	break;
	331	c++;
	332	}
	333	ptr = (void ) p;
	334	if ((!t) \|\| (strcmp(t,c)==0)) return (char *) 0;
	335
	336	if (!SwigPtrSort) {
	337	qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
	338	for (i = 0; i < 256; i++) SwigStart[i] = SwigPtrN;
	339	for (i = SwigPtrN-1; i >= 0; i--) SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
	340	for (i = 255; i >= 1; i--) {
	341	if (SwigStart[i-1] > SwigStart[i])
	342	SwigStart[i-1] = SwigStart[i];
	343	}
	344	SwigPtrSort = 1;
	345	for (i = 0; i < SWIG_CACHESIZE; i++) SwigCache[i].stat = 0;
	346	}
	347	/* First check cache for matches. Uses last cache value as starting point */
	348	cache = &SwigCache[SwigLastCache];
	349	for (i = 0; i < SWIG_CACHESIZE; i++) {
	350	if (cache->stat && (strcmp(t,cache->name) == 0) && (strcmp(c,cache->mapped) == 0)) {
	351	cache->stat++;
	352	if (cache->tp->cast) ptr = ((cache->tp->cast))(*ptr);
	353	return (char *) 0;
	354	}
	355	SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
	356	if (!SwigLastCache) cache = SwigCache;
	357	else cache++;
	358	}
	359	/* Type mismatch. Look through type-mapping table */
	360	start = SwigStart[(int) t[1]];
	361	end = SwigStart[(int) t[1]+1];
	362	sp = &SwigPtrTable[start];
	363
	364	/* Try to find a match */
	365	while (start <= end) {
	366	if (strncmp(t,sp->name,sp->len) == 0) {
	367	name = sp->name;
	368	len = sp->len;
	369	tp = sp->next;
	370	/* Try to find entry for our given datatype */
	371	while(tp) {
	372	if (tp->len >= 255) {
	373	return c;
	374	}
	375	strcpy(temp_type,tp->name);
	376	strncat(temp_type,t+len,255-tp->len);
	377	if (strcmp(c,temp_type) == 0) {
	378	strcpy(SwigCache[SwigCacheIndex].mapped,c);
	379	strcpy(SwigCache[SwigCacheIndex].name,t);
	380	SwigCache[SwigCacheIndex].stat = 1;
	381	SwigCache[SwigCacheIndex].tp = tp;
	382	SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
	383	/* Get pointer value */
	384	ptr = (void ) p;
	385	if (tp->cast) ptr = ((tp->cast))(*ptr);
	386	return (char *) 0;
	387	}
	388	tp = tp->next;
	389	}
	390	}
	391	sp++;
	392	start++;
	393	}
	394	return c;
	395	}
	396
	397	/* New object-based GetPointer function. This uses the Python abstract
	398	* object interface to automatically dereference the 'this' attribute
	399	* of shadow objects. */
	400
	401	SWIGSTATICRUNTIME(char *)
	402	SWIG_GetPtrObj(PyObject obj, void ptr, char type) {
	403	PyObject *sobj = obj;
	404	char *str;
	405	if (!PyString_Check(obj)) {
	406	if (!PyInstance_Check(obj) \|\| !(sobj = PyObject_GetAttrString(obj,"this")))
	407	return "";
	408	// PyObject_GetAttrString increases sobj refcout !
	409	Py_DECREF(sobj);
	410	}
	411	str = PyString_AsString(sobj);
	412	return SWIG_GetPtr(str,ptr,type);
	413	}
	414
	415
	416	#ifdef __cplusplus
	417	}
	418	#endif
	419
	420
	421
	422
	423
	424
	425
	426
	427
	428
	429
	430
	431
	432
	433
	434
	435
	436