[wxWidgets.git] / wxPython / wxSWIG / swig_lib / swigptr.swg

/*****************************************************************************
 * $Header$
 *
 * swigptr.swg
 *
 * This file contains supporting code for the SWIG run-time type checking
 * mechanism.  The following functions are available :
 *
 * SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *));
 *
 *      Registers a new type-mapping with the type-checker.  origtype is the
 *      original datatype and newtype is an equivalent type.  cast is optional
 *      pointer to a function to cast pointer values between types (this
 *      is typically used to cast pointers from derived classes to base classes in C++)
 *      
 * SWIG_MakePtr(char *buffer, void *ptr, char *typestring);
 *     
 *      Makes a pointer string from a pointer and typestring.  The result is returned
 *      in buffer which is assumed to hold enough space for the result.
 *
 * char * SWIG_GetPtr(char *buffer, void **ptr, char *type)
 *
 *      Gets a pointer value from a string.  If there is a type-mismatch, returns
 *      a character string to the received type.  On success, returns NULL.
 *
 *
 * You can remap these functions by making a file called "swigptr.swg" in
 * your the same directory as the interface file you are wrapping.
 *
 * These functions are normally declared static, but this file can be
 * can be used in a multi-module environment by redefining the symbol
 * SWIGSTATIC.
 *****************************************************************************/

#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef SWIG_GLOBAL
#define SWIGSTATIC
#endif

#ifndef SWIGSTATIC
#define SWIGSTATIC static
#endif


/* 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;

/* Some variables  */

static int SwigPtrMax  = 64;           /* Max entries that can be currently held */
                                       /* This value may be adjusted dynamically */
static int SwigPtrN    = 0;            /* Current number of entries              */
static int SwigPtrSort = 0;            /* Status flag indicating sort            */
static int SwigStart[256];             /* Starting positions of types            */

/* Pointer table */
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);
}

/* Binary Search function */
static int swigcmp(const void *key, const void *data) {
  char *k = (char *) key;
  SwigPtrType *d = (SwigPtrType *) data;
  return strncmp(k,d->name,d->len);
}

/* Register a new datatype with the type-checker */

SWIGSTATIC 
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));
    SwigPtrN = 0;
  }
  /* 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;
    SwigPtrN++;
  }

  /* Check for existing entry */

  while (t->next) {
    if ((strcmp(t->name,newtype) == 0)) {
      if (cast) t->cast = cast;
      return;
    }
    t = t->next;
  }
  
  /* Now place entry (in sorted order) */

  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 */

SWIGSTATIC 
void SWIG_MakePtr(char *_c, const void *_ptr, char *type) {
  static char _hex[16] =
  {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
   'a', 'b', 'c', 'd', 'e', 'f'};
  unsigned long _p, _s;
  char _result[20], *_r;    /* Note : a 64-bit hex number = 16 digits */
  _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--);
  } else {
    strcpy (_c, "NULL");
  }
  if (_ptr)
    strcpy (_c, type);
}

/* Define for backwards compatibility */

#define _swig_make_hex   SWIG_MakePtr 

/* Function for getting a pointer value */

SWIGSTATIC 
char *SWIG_GetPtr(char *_c, void **ptr, char *_t)
{
  unsigned long _p;
  char temp_type[256];
  char *name;
  int  i, len;
  SwigPtrType *sp,*tp;
  SwigCacheType *cache;
  int  start, end;
  _p = 0;

  /* Pointer values must start with leading underscore */
  if (*_c == '_') {
      _c++;
      /* Extract hex value from pointer */
      while (*_c) {
	  if ((*_c >= '0') && (*_c <= '9'))
	    _p = (_p << 4) + (*_c - '0');
	  else if ((*_c >= 'a') && (*_c <= 'f'))
	    _p = (_p << 4) + ((*_c - 'a') + 10);
	  else
	    break;
	  _c++;
      }

      if (_t) {
	if (strcmp(_t,_c)) { 
	  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) {
	      if (strcmp(_t,cache->name) == 0) {
		if (strcmp(_c,cache->mapped) == 0) {
		  cache->stat++;
		  *ptr = (void *) _p;
		  if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
		  return (char *) 0;
		}
	      }
	    }
	    SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
	    if (!SwigLastCache) cache = SwigCache;
	    else cache++;
	  }
	  /* We have a type mismatch.  Will have to look through our type
	     mapping table to figure out whether or not we can accept this datatype */

	  start = SwigStart[(int) _t[1]];
	  end = SwigStart[(int) _t[1]+1];
	  sp = &SwigPtrTable[start];
	  while (start < end) {
	    if (swigcmp(_t,sp) == 0) break;
	    sp++;
	    start++;
	  }
	  if (start > end) sp = 0;
	  /* Try to find a match for this */
	  while (start <= end) {
	    if (swigcmp(_t,sp) == 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++;
	  }
	  /* Didn't find any sort of match for this data.  
	     Get the pointer value and return the received type */
	  *ptr = (void *) _p;
	  return _c;
	} else {
	  /* Found a match on the first try.  Return pointer value */
	  *ptr = (void *) _p;
	  return (char *) 0;
	}
      } else {
	/* No type specified.  Good luck */
	*ptr = (void *) _p;
	return (char *) 0;
      }
  } else {
    if (strcmp (_c, "NULL") == 0) {
	*ptr = (void *) 0;
	return (char *) 0;
    }
    *ptr = (void *) 0;	
    return _c;
  }
}

/* Compatibility mode */

#define _swig_get_hex  SWIG_GetPtr

#ifdef __cplusplus
}
#endif
Commit	Line	Data
c90f71dd RD	1	/*****************************************************************************
	2	* $Header$
	3	*
	4	* swigptr.swg
	5	*
	6	* This file contains supporting code for the SWIG run-time type checking
	7	* mechanism. The following functions are available :
	8	*
	9	* SWIG_RegisterMapping(char origtype, char newtype, void (cast)(void *));
	10	*
	11	* Registers a new type-mapping with the type-checker. origtype is the
	12	* original datatype and newtype is an equivalent type. cast is optional
	13	* pointer to a function to cast pointer values between types (this
	14	* is typically used to cast pointers from derived classes to base classes in C++)
	15	*
	16	* SWIG_MakePtr(char buffer, void ptr, char *typestring);
	17	*
	18	* Makes a pointer string from a pointer and typestring. The result is returned
	19	* in buffer which is assumed to hold enough space for the result.
	20	*
	21	* char * SWIG_GetPtr(char buffer, void ptr, char type)
	22	*
	23	* Gets a pointer value from a string. If there is a type-mismatch, returns
	24	* a character string to the received type. On success, returns NULL.
	25	*
	26	*
	27	* You can remap these functions by making a file called "swigptr.swg" in
	28	* your the same directory as the interface file you are wrapping.
	29	*
	30	* These functions are normally declared static, but this file can be
	31	* can be used in a multi-module environment by redefining the symbol
	32	* SWIGSTATIC.
	33	*****************************************************************************/
	34
	35	#include <stdlib.h>
	36
	37	#ifdef __cplusplus
	38	extern "C" {
	39	#endif
	40
	41	#ifdef SWIG_GLOBAL
	42	#define SWIGSTATIC
	43	#endif
	44
	45	#ifndef SWIGSTATIC
	46	#define SWIGSTATIC static
	47	#endif
	48
	49
	50
	51	/* SWIG pointer structure */
	52
	53	typedef struct SwigPtrType {
	54	char name; / Datatype name */
	55	int len; /* Length (used for optimization) */
	56	void (cast)(void ); / Pointer casting function */
	57	struct SwigPtrType next; / Linked list pointer */
	58	} SwigPtrType;
	59
	60	/* Pointer cache structure */
	61
	62	typedef struct {
	63	int stat; /* Status (valid) bit */
	64	SwigPtrType tp; / Pointer to type structure */
65	char name[256]; /* Given datatype name */
66	char mapped[256]; /* Equivalent name */
67	} SwigCacheType;
68
69	/* Some variables */
70
71	static int SwigPtrMax = 64; /* Max entries that can be currently held */
72	/* This value may be adjusted dynamically */
73	static int SwigPtrN = 0; /* Current number of entries */
74	static int SwigPtrSort = 0; /* Status flag indicating sort */
75	static int SwigStart[256]; /* Starting positions of types */
76
77	/* Pointer table */
78	static SwigPtrType SwigPtrTable = 0; / Table containing pointer equivalences */
79
80	/* Cached values */
81
82	#define SWIG_CACHESIZE 8
83	#define SWIG_CACHEMASK 0x7
84	static SwigCacheType SwigCache[SWIG_CACHESIZE];
85	static int SwigCacheIndex = 0;
86	static int SwigLastCache = 0;
87
88	/* Sort comparison function */
89	static int swigsort(const void data1, const void data2) {
90	SwigPtrType d1 = (SwigPtrType ) data1;
91	SwigPtrType d2 = (SwigPtrType ) data2;
92	return strcmp(d1->name,d2->name);
93	}
94
95	/* Binary Search function */
96	static int swigcmp(const void key, const void data) {
97	char k = (char ) key;
98	SwigPtrType d = (SwigPtrType ) data;
99	return strncmp(k,d->name,d->len);
100	}
101
102	/* Register a new datatype with the type-checker */
103
104	SWIGSTATIC
105	void SWIG_RegisterMapping(char origtype, char newtype, void (cast)(void *)) {
106
107	int i;
108	SwigPtrType t = 0,t1;
109
110	/* Allocate the pointer table if necessary */
111
112	if (!SwigPtrTable) {
113	SwigPtrTable = (SwigPtrType ) malloc(SwigPtrMaxsizeof(SwigPtrType));
114	SwigPtrN = 0;
115	}
116	/* Grow the table */
117	if (SwigPtrN >= SwigPtrMax) {
118	SwigPtrMax = 2*SwigPtrMax;
119	SwigPtrTable = (SwigPtrType ) realloc((char ) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
120	}
121	for (i = 0; i < SwigPtrN; i++)
122	if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
123	t = &SwigPtrTable[i];
124	break;
125	}
126	if (!t) {
127	t = &SwigPtrTable[SwigPtrN];
128	t->name = origtype;
129	t->len = strlen(t->name);
130	t->cast = 0;
131	t->next = 0;
132	SwigPtrN++;
133	}
134
135	/* Check for existing entry */
136
137	while (t->next) {
138	if ((strcmp(t->name,newtype) == 0)) {
139	if (cast) t->cast = cast;
140	return;
141	}
142	t = t->next;
143	}
144
145	/* Now place entry (in sorted order) */
146
147	t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
148	t1->name = newtype;
149	t1->len = strlen(t1->name);
150	t1->cast = cast;
151	t1->next = 0;
152	t->next = t1;
153	SwigPtrSort = 0;
154	}
155
156	/* Make a pointer value string */
157
158	SWIGSTATIC
159	void SWIG_MakePtr(char _c, const void _ptr, char *type) {
160	static char _hex[16] =
161	{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
162	'a', 'b', 'c', 'd', 'e', 'f'};
163	unsigned long _p, _s;
164	char _result[20], _r; / Note : a 64-bit hex number = 16 digits */
165	_r = _result;
166	_p = (unsigned long) _ptr;
167	if (_p > 0) {
168	while (_p > 0) {
169	_s = _p & 0xf;
170	*(_r++) = _hex[_s];
171	_p = _p >> 4;
172	}
173	*_r = '_';
174	while (_r >= _result)
175	(_c++) = (_r--);
176	} else {
177	strcpy (_c, "NULL");
178	}
179	if (_ptr)
180	strcpy (_c, type);
181	}
182
183	/* Define for backwards compatibility */
184
185	#define _swig_make_hex SWIG_MakePtr
186
187	/* Function for getting a pointer value */
188
189	SWIGSTATIC
190	char SWIG_GetPtr(char _c, void *ptr, char _t)
191	{
192	unsigned long _p;
193	char temp_type[256];
194	char *name;
195	int i, len;
196	SwigPtrType sp,tp;
197	SwigCacheType *cache;
198	int start, end;
199	_p = 0;
200
201	/* Pointer values must start with leading underscore */
202	if (*_c == '_') {
203	_c++;
204	/* Extract hex value from pointer */
205	while (*_c) {
206	if ((_c >= '0') && (_c <= '9'))
207	_p = (_p << 4) + (*_c - '0');
208	else if ((_c >= 'a') && (_c <= 'f'))
209	_p = (_p << 4) + ((*_c - 'a') + 10);
210	else
211	break;
212	_c++;
213	}
214
215	if (_t) {
216	if (strcmp(_t,_c)) {
217	if (!SwigPtrSort) {
218	qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
219	for (i = 0; i < 256; i++) {
220	SwigStart[i] = SwigPtrN;
221	}
222	for (i = SwigPtrN-1; i >= 0; i--) {
223	SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
224	}
225	for (i = 255; i >= 1; i--) {
226	if (SwigStart[i-1] > SwigStart[i])
227	SwigStart[i-1] = SwigStart[i];
228	}
229	SwigPtrSort = 1;
230	for (i = 0; i < SWIG_CACHESIZE; i++)
231	SwigCache[i].stat = 0;
232	}
233
234	/* First check cache for matches. Uses last cache value as starting point */
235	cache = &SwigCache[SwigLastCache];
236	for (i = 0; i < SWIG_CACHESIZE; i++) {
237	if (cache->stat) {
238	if (strcmp(_t,cache->name) == 0) {
239	if (strcmp(_c,cache->mapped) == 0) {
240	cache->stat++;
241	ptr = (void ) _p;
242	if (cache->tp->cast) ptr = ((cache->tp->cast))(*ptr);
243	return (char *) 0;
244	}
245	}
246	}
247	SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
248	if (!SwigLastCache) cache = SwigCache;
249	else cache++;
250	}
251	/* We have a type mismatch. Will have to look through our type
252	mapping table to figure out whether or not we can accept this datatype */
253
254	start = SwigStart[(int) _t[1]];
255	end = SwigStart[(int) _t[1]+1];
256	sp = &SwigPtrTable[start];
257	while (start < end) {
258	if (swigcmp(_t,sp) == 0) break;
259	sp++;
260	start++;
261	}
262	if (start > end) sp = 0;
263	/* Try to find a match for this */
264	while (start <= end) {
265	if (swigcmp(_t,sp) == 0) {
266	name = sp->name;
267	len = sp->len;
268	tp = sp->next;
269	/* Try to find entry for our given datatype */
270	while(tp) {
271	if (tp->len >= 255) {
272	return _c;
273	}
274	strcpy(temp_type,tp->name);
275	strncat(temp_type,_t+len,255-tp->len);
276	if (strcmp(_c,temp_type) == 0) {
277
278	strcpy(SwigCache[SwigCacheIndex].mapped,_c);
279	strcpy(SwigCache[SwigCacheIndex].name,_t);
280	SwigCache[SwigCacheIndex].stat = 1;
281	SwigCache[SwigCacheIndex].tp = tp;
282	SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
283
284	/* Get pointer value */
285	ptr = (void ) _p;
286	if (tp->cast) ptr = ((tp->cast))(*ptr);
287	return (char *) 0;
288	}
289	tp = tp->next;
290	}
291	}
292	sp++;
293	start++;
294	}
295	/* Didn't find any sort of match for this data.
296	Get the pointer value and return the received type */
297	ptr = (void ) _p;
298	return _c;
299	} else {
300	/* Found a match on the first try. Return pointer value */
301	ptr = (void ) _p;
302	return (char *) 0;
303	}
304	} else {
305	/* No type specified. Good luck */
306	ptr = (void ) _p;
307	return (char *) 0;
308	}
309	} else {
310	if (strcmp (_c, "NULL") == 0) {
311	ptr = (void ) 0;
312	return (char *) 0;
313	}
314	ptr = (void ) 0;
315	return _c;
316	}
317	}
318
319	/* Compatibility mode */
320
321	#define _swig_get_hex SWIG_GetPtr
322
323	#ifdef __cplusplus
324	}
325	#endif
326