[wxWidgets.git] / wxPython / wxSWIG / Runtime / libtcl.c

/*
 * $Header$
 * 
 * swigtcl.swg
 */

#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

/*****************************************************************************
 * $Header$
 *
 * swigptr.swg
 *****************************************************************************/

#include <stdlib.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifdef SWIG_NOINCLUDE
extern void SWIG_MakePtr(char *, void *, char *);
extern void SWIG_RegisterMapping(char *, char *, void *(*)(void *));
extern char *SWIG_GetPtr(char *, void **, char *);
#else

#ifdef SWIG_GLOBAL
#define SWIGSTATICRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGSTATICRUNTIME(a) static a
#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;

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;
} 

#endif
  
#ifdef __cplusplus
}
#endif
Commit	Line	Data
c90f71dd RD	1	/*
	2	* $Header$
	3	*
	4	* swigtcl.swg
	5	*/
	6
	7	#if defined(_WIN32) \|\| defined(__WIN32__)
	8	# if defined(_MSC_VER)
	9	# define SWIGEXPORT(a) __declspec(dllexport) a
	10	# else
	11	# if defined(__BORLANDC__)
	12	# define SWIGEXPORT(a) a _export
	13	# else
	14	# define SWIGEXPORT(a) a
	15	# endif
	16	# endif
	17	#else
	18	# define SWIGEXPORT(a) a
	19	#endif
	20
	21	/*****************************************************************************
	22	* $Header$
	23	*
	24	* swigptr.swg
	25	*****************************************************************************/
	26
	27	#include <stdlib.h>
	28
	29	#ifdef __cplusplus
	30	extern "C" {
	31	#endif
	32
	33	#ifdef SWIG_NOINCLUDE
	34	extern void SWIG_MakePtr(char , void , char *);
	35	extern void SWIG_RegisterMapping(char , char , void ()(void *));
	36	extern char SWIG_GetPtr(char , void *, char );
	37	#else
	38
	39	#ifdef SWIG_GLOBAL
	40	#define SWIGSTATICRUNTIME(a) SWIGEXPORT(a)
	41	#else
	42	#define SWIGSTATICRUNTIME(a) static a
	43	#endif
	44
	45	/* SWIG pointer structure */
	46	typedef struct SwigPtrType {
	47	char name; / Datatype name */
	48	int len; /* Length (used for optimization) */
	49	void (cast)(void ); / Pointer casting function */
	50	struct SwigPtrType next; / Linked list pointer */
	51	} SwigPtrType;
	52
	53	/* Pointer cache structure */
	54	typedef struct {
	55	int stat; /* Status (valid) bit */
	56	SwigPtrType tp; / Pointer to type structure */
	57	char name[256]; /* Given datatype name */
	58	char mapped[256]; /* Equivalent name */
	59	} SwigCacheType;
	60
	61	static int SwigPtrMax = 64; /* Max entries that can be currently held */
	62	static int SwigPtrN = 0; /* Current number of entries */
	63	static int SwigPtrSort = 0; /* Status flag indicating sort */
	64	static int SwigStart[256]; /* Starting positions of types */
65	static SwigPtrType SwigPtrTable = 0; / Table containing pointer equivalences */
66
67	/* Cached values */
68	#define SWIG_CACHESIZE 8
69	#define SWIG_CACHEMASK 0x7
70	static SwigCacheType SwigCache[SWIG_CACHESIZE];
71	static int SwigCacheIndex = 0;
72	static int SwigLastCache = 0;
73
74	/* Sort comparison function */
75	static int swigsort(const void data1, const void data2) {
76	SwigPtrType d1 = (SwigPtrType ) data1;
77	SwigPtrType d2 = (SwigPtrType ) data2;
78	return strcmp(d1->name,d2->name);
79	}
80
81	/* Register a new datatype with the type-checker */
82	SWIGSTATICRUNTIME(void)
83	SWIG_RegisterMapping(char origtype, char newtype, void (cast)(void *)) {
84	int i;
85	SwigPtrType t = 0,t1;
86
87	/* Allocate the pointer table if necessary */
88	if (!SwigPtrTable) {
89	SwigPtrTable = (SwigPtrType ) malloc(SwigPtrMaxsizeof(SwigPtrType));
90	}
91
92	/* Grow the table */
93	if (SwigPtrN >= SwigPtrMax) {
94	SwigPtrMax = 2*SwigPtrMax;
95	SwigPtrTable = (SwigPtrType ) realloc((char ) SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
96	}
97	for (i = 0; i < SwigPtrN; i++) {
98	if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
99	t = &SwigPtrTable[i];
100	break;
101	}
102	}
103	if (!t) {
104	t = &SwigPtrTable[SwigPtrN++];
105	t->name = origtype;
106	t->len = strlen(t->name);
107	t->cast = 0;
108	t->next = 0;
109	}
110
111	/* Check for existing entries */
112	while (t->next) {
113	if ((strcmp(t->name,newtype) == 0)) {
114	if (cast) t->cast = cast;
115	return;
116	}
117	t = t->next;
118	}
119	t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
120	t1->name = newtype;
121	t1->len = strlen(t1->name);
122	t1->cast = cast;
123	t1->next = 0;
124	t->next = t1;
125	SwigPtrSort = 0;
126	}
127
128	/* Make a pointer value string */
129	SWIGSTATICRUNTIME(void)
130	SWIG_MakePtr(char c, const void ptr, char *type) {
131	static char hex[17] = "0123456789abcdef";
132	unsigned long p, s;
133	char result[24], *r;
134	r = result;
135	p = (unsigned long) ptr;
136	if (p > 0) {
137	while (p > 0) {
138	s = p & 0xf;
139	*(r++) = hex[s];
140	p = p >> 4;
141	}
142	*r = '_';
143	while (r >= result)
144	(c++) = (r--);
145	strcpy (c, type);
146	} else {
147	strcpy (c, "NULL");
148	}
149	}
150
151	/* Function for getting a pointer value */
152	SWIGSTATICRUNTIME(char *)
153	SWIG_GetPtr(char c, void ptr, char t)
154	{
155	unsigned long p;
156	char temp_type[256], *name;
157	int i, len, start, end;
158	SwigPtrType sp,tp;
159	SwigCacheType *cache;
160	register int d;
161
162	p = 0;
163	/* Pointer values must start with leading underscore */
164	if (*c != '_') {
165	ptr = (void ) 0;
166	if (strcmp(c,"NULL") == 0) return (char *) 0;
167	else c;
168	}
169	c++;
170	/* Extract hex value from pointer */
171	while (d = *c) {
172	if ((d >= '0') && (d <= '9'))
173	p = (p << 4) + (d - '0');
174	else if ((d >= 'a') && (d <= 'f'))
175	p = (p << 4) + (d - ('a'-10));
176	else
177	break;
178	c++;
179	}
180	ptr = (void ) p;
181	if ((!t) \|\| (strcmp(t,c)==0)) return (char *) 0;
182
183	if (!SwigPtrSort) {
184	qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
185	for (i = 0; i < 256; i++) SwigStart[i] = SwigPtrN;
186	for (i = SwigPtrN-1; i >= 0; i--) SwigStart[(int) (SwigPtrTable[i].name[1])] = i;
187	for (i = 255; i >= 1; i--) {
188	if (SwigStart[i-1] > SwigStart[i])
189	SwigStart[i-1] = SwigStart[i];
190	}
191	SwigPtrSort = 1;
192	for (i = 0; i < SWIG_CACHESIZE; i++) SwigCache[i].stat = 0;
193	}
194	/* First check cache for matches. Uses last cache value as starting point */
195	cache = &SwigCache[SwigLastCache];
196	for (i = 0; i < SWIG_CACHESIZE; i++) {
197	if (cache->stat && (strcmp(t,cache->name) == 0) && (strcmp(c,cache->mapped) == 0)) {
198	cache->stat++;
199	if (cache->tp->cast) ptr = ((cache->tp->cast))(*ptr);
200	return (char *) 0;
201	}
202	SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
203	if (!SwigLastCache) cache = SwigCache;
204	else cache++;
205	}
206	/* Type mismatch. Look through type-mapping table */
207	start = SwigStart[(int) t[1]];
208	end = SwigStart[(int) t[1]+1];
209	sp = &SwigPtrTable[start];
210
211	/* Try to find a match */
212	while (start <= end) {
213	if (strncmp(t,sp->name,sp->len) == 0) {
214	name = sp->name;
215	len = sp->len;
216	tp = sp->next;
217	/* Try to find entry for our given datatype */
218	while(tp) {
219	if (tp->len >= 255) {
220	return c;
221	}
222	strcpy(temp_type,tp->name);
223	strncat(temp_type,t+len,255-tp->len);
224	if (strcmp(c,temp_type) == 0) {
225	strcpy(SwigCache[SwigCacheIndex].mapped,c);
226	strcpy(SwigCache[SwigCacheIndex].name,t);
227	SwigCache[SwigCacheIndex].stat = 1;
228	SwigCache[SwigCacheIndex].tp = tp;
229	SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
230	/* Get pointer value */
231	ptr = (void ) p;
232	if (tp->cast) ptr = ((tp->cast))(*ptr);
233	return (char *) 0;
234	}
235	tp = tp->next;
236	}
237	}
238	sp++;
239	start++;
240	}
241	return c;
242	}
243
244	#endif
245
246	#ifdef __cplusplus
247	}
248	#endif
249