Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

source: branches/samba-3.3.x/source/lib/tdb/tdb_wrap.c

Visit:

Last change on this file was 206, checked in by Herwig Bauernfeind, 16 years ago
Import Samba 3.3 branch at 3.0.0 level (psmedley's port)
File size: 126.7 KB

Line
1	/* ----------------------------------------------------------------------------
2	* This file was automatically generated by SWIG (http://www.swig.org).
3	* Version 1.3.35
4	*
5	* This file is not intended to be easily readable and contains a number of
6	* coding conventions designed to improve portability and efficiency. Do not make
7	* changes to this file unless you know what you are doing--modify the SWIG
8	* interface file instead.
9	* ----------------------------------------------------------------------------- */
10
11	#define SWIGPYTHON
12	#define SWIG_PYTHON_NO_BUILD_NONE
13	/* -----------------------------------------------------------------------------
14	* This section contains generic SWIG labels for method/variable
15	* declarations/attributes, and other compiler dependent labels.
16	* ----------------------------------------------------------------------------- */
17
18	/* template workaround for compilers that cannot correctly implement the C++ standard */
19	#ifndef SWIGTEMPLATEDISAMBIGUATOR
20	# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
21	# define SWIGTEMPLATEDISAMBIGUATOR template
22	# elif defined(__HP_aCC)
23	/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
24	/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
25	# define SWIGTEMPLATEDISAMBIGUATOR template
26	# else
27	# define SWIGTEMPLATEDISAMBIGUATOR
28	# endif
29	#endif
30
31	/* inline attribute */
32	#ifndef SWIGINLINE
33	# if defined(__cplusplus) \|\| (defined(__GNUC__) && !defined(__STRICT_ANSI__))
34	# define SWIGINLINE inline
35	# else
36	# define SWIGINLINE
37	# endif
38	#endif
39
40	/* attribute recognised by some compilers to avoid 'unused' warnings */
41	#ifndef SWIGUNUSED
42	# if defined(__GNUC__)
43	# if !(defined(__cplusplus)) \|\| (__GNUC__ > 3 \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
44	# define SWIGUNUSED __attribute__ ((__unused__))
45	# else
46	# define SWIGUNUSED
47	# endif
48	# elif defined(__ICC)
49	# define SWIGUNUSED __attribute__ ((__unused__))
50	# else
51	# define SWIGUNUSED
52	# endif
53	#endif
54
55	#ifndef SWIGUNUSEDPARM
56	# ifdef __cplusplus
57	# define SWIGUNUSEDPARM(p)
58	# else
59	# define SWIGUNUSEDPARM(p) p SWIGUNUSED
60	# endif
61	#endif
62
63	/* internal SWIG method */
64	#ifndef SWIGINTERN
65	# define SWIGINTERN static SWIGUNUSED
66	#endif
67
68	/* internal inline SWIG method */
69	#ifndef SWIGINTERNINLINE
70	# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
71	#endif
72
73	/* exporting methods */
74	#if (__GNUC__ >= 4) \|\| (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
75	# ifndef GCC_HASCLASSVISIBILITY
76	# define GCC_HASCLASSVISIBILITY
77	# endif
78	#endif
79
80	#ifndef SWIGEXPORT
81	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
82	# if defined(STATIC_LINKED)
83	# define SWIGEXPORT
84	# else
85	# define SWIGEXPORT __declspec(dllexport)
86	# endif
87	# else
88	# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
89	# define SWIGEXPORT __attribute__ ((visibility("default")))
90	# else
91	# define SWIGEXPORT
92	# endif
93	# endif
94	#endif
95
96	/* calling conventions for Windows */
97	#ifndef SWIGSTDCALL
98	# if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
99	# define SWIGSTDCALL __stdcall
100	# else
101	# define SWIGSTDCALL
102	# endif
103	#endif
104
105	/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
106	#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
107	# define _CRT_SECURE_NO_DEPRECATE
108	#endif
109
110	/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
111	#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
112	# define _SCL_SECURE_NO_DEPRECATE
113	#endif
114
115
116
117	/* Python.h has to appear first */
118	#include <Python.h>
119
120	/* -----------------------------------------------------------------------------
121	* swigrun.swg
122	*
123	* This file contains generic CAPI SWIG runtime support for pointer
124	* type checking.
125	* ----------------------------------------------------------------------------- */
126
127	/* This should only be incremented when either the layout of swig_type_info changes,
128	or for whatever reason, the runtime changes incompatibly */
129	#define SWIG_RUNTIME_VERSION "4"
130
131	/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
132	#ifdef SWIG_TYPE_TABLE
133	# define SWIG_QUOTE_STRING(x) #x
134	# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
135	# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
136	#else
137	# define SWIG_TYPE_TABLE_NAME
138	#endif
139
140	/*
141	You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
142	creating a static or dynamic library from the swig runtime code.
143	In 99.9% of the cases, swig just needs to declare them as 'static'.
144
145	But only do this if is strictly necessary, ie, if you have problems
146	with your compiler or so.
147	*/
148
149	#ifndef SWIGRUNTIME
150	# define SWIGRUNTIME SWIGINTERN
151	#endif
152
153	#ifndef SWIGRUNTIMEINLINE
154	# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
155	#endif
156
157	/* Generic buffer size */
158	#ifndef SWIG_BUFFER_SIZE
159	# define SWIG_BUFFER_SIZE 1024
160	#endif
161
162	/* Flags for pointer conversions */
163	#define SWIG_POINTER_DISOWN 0x1
164	#define SWIG_CAST_NEW_MEMORY 0x2
165
166	/* Flags for new pointer objects */
167	#define SWIG_POINTER_OWN 0x1
168
169
170	/*
171	Flags/methods for returning states.
172
173	The swig conversion methods, as ConvertPtr, return and integer
174	that tells if the conversion was successful or not. And if not,
175	an error code can be returned (see swigerrors.swg for the codes).
176
177	Use the following macros/flags to set or process the returning
178	states.
179
180	In old swig versions, you usually write code as:
181
182	if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
183	// success code
184	} else {
185	//fail code
186	}
187
188	Now you can be more explicit as:
189
190	int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
191	if (SWIG_IsOK(res)) {
192	// success code
193	} else {
194	// fail code
195	}
196
197	that seems to be the same, but now you can also do
198
199	Type *ptr;
200	int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
201	if (SWIG_IsOK(res)) {
202	// success code
203	if (SWIG_IsNewObj(res) {
204	...
205	delete *ptr;
206	} else {
207	...
208	}
209	} else {
210	// fail code
211	}
212
213	I.e., now SWIG_ConvertPtr can return new objects and you can
214	identify the case and take care of the deallocation. Of course that
215	requires also to SWIG_ConvertPtr to return new result values, as
216
217	int SWIG_ConvertPtr(obj, ptr,...) {
218	if (<obj is ok>) {
219	if (<need new object>) {
220	*ptr = <ptr to new allocated object>;
221	return SWIG_NEWOBJ;
222	} else {
223	*ptr = <ptr to old object>;
224	return SWIG_OLDOBJ;
225	}
226	} else {
227	return SWIG_BADOBJ;
228	}
229	}
230
231	Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
232	more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
233	swig errors code.
234
235	Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
236	allows to return the 'cast rank', for example, if you have this
237
238	int food(double)
239	int fooi(int);
240
241	and you call
242
243	food(1) // cast rank '1' (1 -> 1.0)
244	fooi(1) // cast rank '0'
245
246	just use the SWIG_AddCast()/SWIG_CheckState()
247
248
249	*/
250	#define SWIG_OK (0)
251	#define SWIG_ERROR (-1)
252	#define SWIG_IsOK(r) (r >= 0)
253	#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
254
255	/* The CastRankLimit says how many bits are used for the cast rank */
256	#define SWIG_CASTRANKLIMIT (1 << 8)
257	/* The NewMask denotes the object was created (using new/malloc) */
258	#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
259	/* The TmpMask is for in/out typemaps that use temporal objects */
260	#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
261	/* Simple returning values */
262	#define SWIG_BADOBJ (SWIG_ERROR)
263	#define SWIG_OLDOBJ (SWIG_OK)
264	#define SWIG_NEWOBJ (SWIG_OK \| SWIG_NEWOBJMASK)
265	#define SWIG_TMPOBJ (SWIG_OK \| SWIG_TMPOBJMASK)
266	/* Check, add and del mask methods */
267	#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r \| SWIG_NEWOBJMASK) : r)
268	#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
269	#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
270	#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r \| SWIG_TMPOBJMASK) : r)
271	#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
272	#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
273
274
275	/* Cast-Rank Mode */
276	#if defined(SWIG_CASTRANK_MODE)
277	# ifndef SWIG_TypeRank
278	# define SWIG_TypeRank unsigned long
279	# endif
280	# ifndef SWIG_MAXCASTRANK /* Default cast allowed */
281	# define SWIG_MAXCASTRANK (2)
282	# endif
283	# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
284	# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
285	SWIGINTERNINLINE int SWIG_AddCast(int r) {
286	return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
287	}
288	SWIGINTERNINLINE int SWIG_CheckState(int r) {
289	return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
290	}
291	#else /* no cast-rank mode */
292	# define SWIG_AddCast
293	# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
294	#endif
295
296
297
298
299	#include <string.h>
300
301	#ifdef __cplusplus
302	extern "C" {
303	#endif
304
305	typedef void (swig_converter_func)(void , int );
306	typedef struct swig_type_info (swig_dycast_func)(void **);
307
308	/* Structure to store information on one type */
309	typedef struct swig_type_info {
310	const char name; / mangled name of this type */
311	const char str; / human readable name of this type */
312	swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
313	struct swig_cast_info cast; / linked list of types that can cast into this type */
314	void clientdata; / language specific type data */
315	int owndata; /* flag if the structure owns the clientdata */
316	} swig_type_info;
317
318	/* Structure to store a type and conversion function used for casting */
319	typedef struct swig_cast_info {
320	swig_type_info type; / pointer to type that is equivalent to this type */
321	swig_converter_func converter; /* function to cast the void pointers */
322	struct swig_cast_info next; / pointer to next cast in linked list */
323	struct swig_cast_info prev; / pointer to the previous cast */
324	} swig_cast_info;
325
326	/* Structure used to store module information
327	* Each module generates one structure like this, and the runtime collects
328	* all of these structures and stores them in a circularly linked list.*/
329	typedef struct swig_module_info {
330	swig_type_info *types; / Array of pointers to swig_type_info structures that are in this module */
331	size_t size; /* Number of types in this module */
332	struct swig_module_info next; / Pointer to next element in circularly linked list */
333	swig_type_info *type_initial; / Array of initially generated type structures */
334	swig_cast_info *cast_initial; / Array of initially generated casting structures */
335	void clientdata; / Language specific module data */
336	} swig_module_info;
337
338	/*
339	Compare two type names skipping the space characters, therefore
340	"char" == "char " and "Class<int>" == "Class<int >", etc.
341
342	Return 0 when the two name types are equivalent, as in
343	strncmp, but skipping ' '.
344	*/
345	SWIGRUNTIME int
346	SWIG_TypeNameComp(const char f1, const char l1,
347	const char f2, const char l2) {
348	for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
349	while ((*f1 == ' ') && (f1 != l1)) ++f1;
350	while ((*f2 == ' ') && (f2 != l2)) ++f2;
351	if (f1 != f2) return (f1 > f2) ? 1 : -1;
352	}
353	return (int)((l1 - f1) - (l2 - f2));
354	}
355
356	/*
357	Check type equivalence in a name list like <name1>\|<name2>\|...
358	Return 0 if not equal, 1 if equal
359	*/
360	SWIGRUNTIME int
361	SWIG_TypeEquiv(const char nb, const char tb) {
362	int equiv = 0;
363	const char* te = tb + strlen(tb);
364	const char* ne = nb;
365	while (!equiv && *ne) {
366	for (nb = ne; *ne; ++ne) {
367	if (*ne == '\|') break;
368	}
369	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
370	if (*ne) ++ne;
371	}
372	return equiv;
373	}
374
375	/*
376	Check type equivalence in a name list like <name1>\|<name2>\|...
377	Return 0 if equal, -1 if nb < tb, 1 if nb > tb
378	*/
379	SWIGRUNTIME int
380	SWIG_TypeCompare(const char nb, const char tb) {
381	int equiv = 0;
382	const char* te = tb + strlen(tb);
383	const char* ne = nb;
384	while (!equiv && *ne) {
385	for (nb = ne; *ne; ++ne) {
386	if (*ne == '\|') break;
387	}
388	equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
389	if (*ne) ++ne;
390	}
391	return equiv;
392	}
393
394
395	/* think of this as a c++ template<> or a scheme macro */
396	#define SWIG_TypeCheck_Template(comparison, ty) \
397	if (ty) { \
398	swig_cast_info *iter = ty->cast; \
399	while (iter) { \
400	if (comparison) { \
401	if (iter == ty->cast) return iter; \
402	/* Move iter to the top of the linked list */ \
403	iter->prev->next = iter->next; \
404	if (iter->next) \
405	iter->next->prev = iter->prev; \
406	iter->next = ty->cast; \
407	iter->prev = 0; \
408	if (ty->cast) ty->cast->prev = iter; \
409	ty->cast = iter; \
410	return iter; \
411	} \
412	iter = iter->next; \
413	} \
414	} \
415	return 0
416
417	/*
418	Check the typename
419	*/
420	SWIGRUNTIME swig_cast_info *
421	SWIG_TypeCheck(const char c, swig_type_info ty) {
422	SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
423	}
424
425	/* Same as previous function, except strcmp is replaced with a pointer comparison */
426	SWIGRUNTIME swig_cast_info *
427	SWIG_TypeCheckStruct(swig_type_info from, swig_type_info into) {
428	SWIG_TypeCheck_Template(iter->type == from, into);
429	}
430
431	/*
432	Cast a pointer up an inheritance hierarchy
433	*/
434	SWIGRUNTIMEINLINE void *
435	SWIG_TypeCast(swig_cast_info ty, void ptr, int *newmemory) {
436	return ((!ty) \|\| (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
437	}
438
439	/*
440	Dynamic pointer casting. Down an inheritance hierarchy
441	*/
442	SWIGRUNTIME swig_type_info *
443	SWIG_TypeDynamicCast(swig_type_info ty, void *ptr) {
444	swig_type_info *lastty = ty;
445	if (!ty \|\| !ty->dcast) return ty;
446	while (ty && (ty->dcast)) {
447	ty = (*ty->dcast)(ptr);
448	if (ty) lastty = ty;
449	}
450	return lastty;
451	}
452
453	/*
454	Return the name associated with this type
455	*/
456	SWIGRUNTIMEINLINE const char *
457	SWIG_TypeName(const swig_type_info *ty) {
458	return ty->name;
459	}
460
461	/*
462	Return the pretty name associated with this type,
463	that is an unmangled type name in a form presentable to the user.
464	*/
465	SWIGRUNTIME const char *
466	SWIG_TypePrettyName(const swig_type_info *type) {
467	/* The "str" field contains the equivalent pretty names of the
468	type, separated by vertical-bar characters. We choose
469	to print the last name, as it is often (?) the most
470	specific. */
471	if (!type) return NULL;
472	if (type->str != NULL) {
473	const char *last_name = type->str;
474	const char *s;
475	for (s = type->str; *s; s++)
476	if (*s == '\|') last_name = s+1;
477	return last_name;
478	}
479	else
480	return type->name;
481	}
482
483	/*
484	Set the clientdata field for a type
485	*/
486	SWIGRUNTIME void
487	SWIG_TypeClientData(swig_type_info ti, void clientdata) {
488	swig_cast_info *cast = ti->cast;
489	/* if (ti->clientdata == clientdata) return; */
490	ti->clientdata = clientdata;
491
492	while (cast) {
493	if (!cast->converter) {
494	swig_type_info *tc = cast->type;
495	if (!tc->clientdata) {
496	SWIG_TypeClientData(tc, clientdata);
497	}
498	}
499	cast = cast->next;
500	}
501	}
502	SWIGRUNTIME void
503	SWIG_TypeNewClientData(swig_type_info ti, void clientdata) {
504	SWIG_TypeClientData(ti, clientdata);
505	ti->owndata = 1;
506	}
507
508	/*
509	Search for a swig_type_info structure only by mangled name
510	Search is a O(log #types)
511
512	We start searching at module start, and finish searching when start == end.
513	Note: if start == end at the beginning of the function, we go all the way around
514	the circular list.
515	*/
516	SWIGRUNTIME swig_type_info *
517	SWIG_MangledTypeQueryModule(swig_module_info *start,
518	swig_module_info *end,
519	const char *name) {
520	swig_module_info *iter = start;
521	do {
522	if (iter->size) {
523	register size_t l = 0;
524	register size_t r = iter->size - 1;
525	do {
526	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
527	register size_t i = (l + r) >> 1;
528	const char *iname = iter->types[i]->name;
529	if (iname) {
530	register int compare = strcmp(name, iname);
531	if (compare == 0) {
532	return iter->types[i];
533	} else if (compare < 0) {
534	if (i) {
535	r = i - 1;
536	} else {
537	break;
538	}
539	} else if (compare > 0) {
540	l = i + 1;
541	}
542	} else {
543	break; /* should never happen */
544	}
545	} while (l <= r);
546	}
547	iter = iter->next;
548	} while (iter != end);
549	return 0;
550	}
551
552	/*
553	Search for a swig_type_info structure for either a mangled name or a human readable name.
554	It first searches the mangled names of the types, which is a O(log #types)
555	If a type is not found it then searches the human readable names, which is O(#types).
556
557	We start searching at module start, and finish searching when start == end.
558	Note: if start == end at the beginning of the function, we go all the way around
559	the circular list.
560	*/
561	SWIGRUNTIME swig_type_info *
562	SWIG_TypeQueryModule(swig_module_info *start,
563	swig_module_info *end,
564	const char *name) {
565	/* STEP 1: Search the name field using binary search */
566	swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
567	if (ret) {
568	return ret;
569	} else {
570	/* STEP 2: If the type hasn't been found, do a complete search
571	of the str field (the human readable name) */
572	swig_module_info *iter = start;
573	do {
574	register size_t i = 0;
575	for (; i < iter->size; ++i) {
576	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
577	return iter->types[i];
578	}
579	iter = iter->next;
580	} while (iter != end);
581	}
582
583	/* neither found a match */
584	return 0;
585	}
586
587	/*
588	Pack binary data into a string
589	*/
590	SWIGRUNTIME char *
591	SWIG_PackData(char c, void ptr, size_t sz) {
592	static const char hex[17] = "0123456789abcdef";
593	register const unsigned char u = (unsigned char ) ptr;
594	register const unsigned char *eu = u + sz;
595	for (; u != eu; ++u) {
596	register unsigned char uu = *u;
597	*(c++) = hex[(uu & 0xf0) >> 4];
598	*(c++) = hex[uu & 0xf];
599	}
600	return c;
601	}
602
603	/*
604	Unpack binary data from a string
605	*/
606	SWIGRUNTIME const char *
607	SWIG_UnpackData(const char c, void ptr, size_t sz) {
608	register unsigned char u = (unsigned char ) ptr;
609	register const unsigned char *eu = u + sz;
610	for (; u != eu; ++u) {
611	register char d = *(c++);
612	register unsigned char uu;
613	if ((d >= '0') && (d <= '9'))
614	uu = ((d - '0') << 4);
615	else if ((d >= 'a') && (d <= 'f'))
616	uu = ((d - ('a'-10)) << 4);
617	else
618	return (char *) 0;
619	d = *(c++);
620	if ((d >= '0') && (d <= '9'))
621	uu \|= (d - '0');
622	else if ((d >= 'a') && (d <= 'f'))
623	uu \|= (d - ('a'-10));
624	else
625	return (char *) 0;
626	*u = uu;
627	}
628	return c;
629	}
630
631	/*
632	Pack 'void *' into a string buffer.
633	*/
634	SWIGRUNTIME char *
635	SWIG_PackVoidPtr(char buff, void ptr, const char *name, size_t bsz) {
636	char *r = buff;
637	if ((2sizeof(void ) + 2) > bsz) return 0;
638	*(r++) = '_';
639	r = SWIG_PackData(r,&ptr,sizeof(void *));
640	if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
641	strcpy(r,name);
642	return buff;
643	}
644
645	SWIGRUNTIME const char *
646	SWIG_UnpackVoidPtr(const char c, void ptr, const char name) {
647	if (*c != '_') {
648	if (strcmp(c,"NULL") == 0) {
649	ptr = (void ) 0;
650	return name;
651	} else {
652	return 0;
653	}
654	}
655	return SWIG_UnpackData(++c,ptr,sizeof(void *));
656	}
657
658	SWIGRUNTIME char *
659	SWIG_PackDataName(char buff, void ptr, size_t sz, const char *name, size_t bsz) {
660	char *r = buff;
661	size_t lname = (name ? strlen(name) : 0);
662	if ((2*sz + 2 + lname) > bsz) return 0;
663	*(r++) = '_';
664	r = SWIG_PackData(r,ptr,sz);
665	if (lname) {
666	strncpy(r,name,lname+1);
667	} else {
668	*r = 0;
669	}
670	return buff;
671	}
672
673	SWIGRUNTIME const char *
674	SWIG_UnpackDataName(const char c, void ptr, size_t sz, const char *name) {
675	if (*c != '_') {
676	if (strcmp(c,"NULL") == 0) {
677	memset(ptr,0,sz);
678	return name;
679	} else {
680	return 0;
681	}
682	}
683	return SWIG_UnpackData(++c,ptr,sz);
684	}
685
686	#ifdef __cplusplus
687	}
688	#endif
689
690	/* Errors in SWIG */
691	#define SWIG_UnknownError -1
692	#define SWIG_IOError -2
693	#define SWIG_RuntimeError -3
694	#define SWIG_IndexError -4
695	#define SWIG_TypeError -5
696	#define SWIG_DivisionByZero -6
697	#define SWIG_OverflowError -7
698	#define SWIG_SyntaxError -8
699	#define SWIG_ValueError -9
700	#define SWIG_SystemError -10
701	#define SWIG_AttributeError -11
702	#define SWIG_MemoryError -12
703	#define SWIG_NullReferenceError -13
704
705
706
707
708	/* Add PyOS_snprintf for old Pythons */
709	#if PY_VERSION_HEX < 0x02020000
710	# if defined(_MSC_VER) \|\| defined(__BORLANDC__) \|\| defined(_WATCOM)
711	# define PyOS_snprintf _snprintf
712	# else
713	# define PyOS_snprintf snprintf
714	# endif
715	#endif
716
717	/* A crude PyString_FromFormat implementation for old Pythons */
718	#if PY_VERSION_HEX < 0x02020000
719
720	#ifndef SWIG_PYBUFFER_SIZE
721	# define SWIG_PYBUFFER_SIZE 1024
722	#endif
723
724	static PyObject *
725	PyString_FromFormat(const char *fmt, ...) {
726	va_list ap;
727	char buf[SWIG_PYBUFFER_SIZE * 2];
728	int res;
729	va_start(ap, fmt);
730	res = vsnprintf(buf, sizeof(buf), fmt, ap);
731	va_end(ap);
732	return (res < 0 \|\| res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
733	}
734	#endif
735
736	/* Add PyObject_Del for old Pythons */
737	#if PY_VERSION_HEX < 0x01060000
738	# define PyObject_Del(op) PyMem_DEL((op))
739	#endif
740	#ifndef PyObject_DEL
741	# define PyObject_DEL PyObject_Del
742	#endif
743
744	/* A crude PyExc_StopIteration exception for old Pythons */
745	#if PY_VERSION_HEX < 0x02020000
746	# ifndef PyExc_StopIteration
747	# define PyExc_StopIteration PyExc_RuntimeError
748	# endif
749	# ifndef PyObject_GenericGetAttr
750	# define PyObject_GenericGetAttr 0
751	# endif
752	#endif
753	/* Py_NotImplemented is defined in 2.1 and up. */
754	#if PY_VERSION_HEX < 0x02010000
755	# ifndef Py_NotImplemented
756	# define Py_NotImplemented PyExc_RuntimeError
757	# endif
758	#endif
759
760
761	/* A crude PyString_AsStringAndSize implementation for old Pythons */
762	#if PY_VERSION_HEX < 0x02010000
763	# ifndef PyString_AsStringAndSize
764	# define PyString_AsStringAndSize(obj, s, len) {s = PyString_AsString(obj); len = s ? strlen(s) : 0;}
765	# endif
766	#endif
767
768	/* PySequence_Size for old Pythons */
769	#if PY_VERSION_HEX < 0x02000000
770	# ifndef PySequence_Size
771	# define PySequence_Size PySequence_Length
772	# endif
773	#endif
774
775
776	/* PyBool_FromLong for old Pythons */
777	#if PY_VERSION_HEX < 0x02030000
778	static
779	PyObject *PyBool_FromLong(long ok)
780	{
781	PyObject *result = ok ? Py_True : Py_False;
782	Py_INCREF(result);
783	return result;
784	}
785	#endif
786
787	/* Py_ssize_t for old Pythons */
788	/* This code is as recommended by: */
789	/* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
790	#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
791	typedef int Py_ssize_t;
792	# define PY_SSIZE_T_MAX INT_MAX
793	# define PY_SSIZE_T_MIN INT_MIN
794	#endif
795
796	/* -----------------------------------------------------------------------------
797	* error manipulation
798	* ----------------------------------------------------------------------------- */
799
800	SWIGRUNTIME PyObject*
801	SWIG_Python_ErrorType(int code) {
802	PyObject* type = 0;
803	switch(code) {
804	case SWIG_MemoryError:
805	type = PyExc_MemoryError;
806	break;
807	case SWIG_IOError:
808	type = PyExc_IOError;
809	break;
810	case SWIG_RuntimeError:
811	type = PyExc_RuntimeError;
812	break;
813	case SWIG_IndexError:
814	type = PyExc_IndexError;
815	break;
816	case SWIG_TypeError:
817	type = PyExc_TypeError;
818	break;
819	case SWIG_DivisionByZero:
820	type = PyExc_ZeroDivisionError;
821	break;
822	case SWIG_OverflowError:
823	type = PyExc_OverflowError;
824	break;
825	case SWIG_SyntaxError:
826	type = PyExc_SyntaxError;
827	break;
828	case SWIG_ValueError:
829	type = PyExc_ValueError;
830	break;
831	case SWIG_SystemError:
832	type = PyExc_SystemError;
833	break;
834	case SWIG_AttributeError:
835	type = PyExc_AttributeError;
836	break;
837	default:
838	type = PyExc_RuntimeError;
839	}
840	return type;
841	}
842
843
844	SWIGRUNTIME void
845	SWIG_Python_AddErrorMsg(const char* mesg)
846	{
847	PyObject *type = 0;
848	PyObject *value = 0;
849	PyObject *traceback = 0;
850
851	if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
852	if (value) {
853	PyObject *old_str = PyObject_Str(value);
854	PyErr_Clear();
855	Py_XINCREF(type);
856	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
857	Py_DECREF(old_str);
858	Py_DECREF(value);
859	} else {
860	PyErr_SetString(PyExc_RuntimeError, mesg);
861	}
862	}
863
864
865
866	#if defined(SWIG_PYTHON_NO_THREADS)
867	# if defined(SWIG_PYTHON_THREADS)
868	# undef SWIG_PYTHON_THREADS
869	# endif
870	#endif
871	#if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
872	# if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
873	# if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
874	# define SWIG_PYTHON_USE_GIL
875	# endif
876	# endif
877	# if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
878	# ifndef SWIG_PYTHON_INITIALIZE_THREADS
879	# define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
880	# endif
881	# ifdef __cplusplus /* C++ code */
882	class SWIG_Python_Thread_Block {
883	bool status;
884	PyGILState_STATE state;
885	public:
886	void end() { if (status) { PyGILState_Release(state); status = false;} }
887	SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
888	~SWIG_Python_Thread_Block() { end(); }
889	};
890	class SWIG_Python_Thread_Allow {
891	bool status;
892	PyThreadState *save;
893	public:
894	void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
895	SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
896	~SWIG_Python_Thread_Allow() { end(); }
897	};
898	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
899	# define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
900	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
901	# define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
902	# else /* C code */
903	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
904	# define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
905	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
906	# define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
907	# endif
908	# else /* Old thread way, not implemented, user must provide it */
909	# if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
910	# define SWIG_PYTHON_INITIALIZE_THREADS
911	# endif
912	# if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
913	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
914	# endif
915	# if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
916	# define SWIG_PYTHON_THREAD_END_BLOCK
917	# endif
918	# if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
919	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
920	# endif
921	# if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
922	# define SWIG_PYTHON_THREAD_END_ALLOW
923	# endif
924	# endif
925	#else /* No thread support */
926	# define SWIG_PYTHON_INITIALIZE_THREADS
927	# define SWIG_PYTHON_THREAD_BEGIN_BLOCK
928	# define SWIG_PYTHON_THREAD_END_BLOCK
929	# define SWIG_PYTHON_THREAD_BEGIN_ALLOW
930	# define SWIG_PYTHON_THREAD_END_ALLOW
931	#endif
932
933	/* -----------------------------------------------------------------------------
934	* Python API portion that goes into the runtime
935	* ----------------------------------------------------------------------------- */
936
937	#ifdef __cplusplus
938	extern "C" {
939	#if 0
940	} /* cc-mode */
941	#endif
942	#endif
943
944	/* -----------------------------------------------------------------------------
945	* Constant declarations
946	* ----------------------------------------------------------------------------- */
947
948	/* Constant Types */
949	#define SWIG_PY_POINTER 4
950	#define SWIG_PY_BINARY 5
951
952	/* Constant information structure */
953	typedef struct swig_const_info {
954	int type;
955	char *name;
956	long lvalue;
957	double dvalue;
958	void *pvalue;
959	swig_type_info **ptype;
960	} swig_const_info;
961
962	#ifdef __cplusplus
963	#if 0
964	{ /* cc-mode */
965	#endif
966	}
967	#endif
968
969
970	/* -----------------------------------------------------------------------------
971	* See the LICENSE file for information on copyright, usage and redistribution
972	* of SWIG, and the README file for authors - http://www.swig.org/release.html.
973	*
974	* pyrun.swg
975	*
976	* This file contains the runtime support for Python modules
977	* and includes code for managing global variables and pointer
978	* type checking.
979	*
980	* ----------------------------------------------------------------------------- */
981
982	/* Common SWIG API */
983
984	/* for raw pointers */
985	#define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
986	#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
987	#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
988	#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
989	#define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
990	#define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
991	#define swig_owntype int
992
993	/* for raw packed data */
994	#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
995	#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
996
997	/* for class or struct pointers */
998	#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
999	#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1000
1001	/* for C or C++ function pointers */
1002	#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1003	#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1004
1005	/* for C++ member pointers, ie, member methods */
1006	#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1007	#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1008
1009
1010	/* Runtime API */
1011
1012	#define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1013	#define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1014	#define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1015
1016	#define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1017	#define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1018	#define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1019	#define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1020	#define SWIG_fail goto fail
1021
1022
1023	/* Runtime API implementation */
1024
1025	/* Error manipulation */
1026
1027	SWIGINTERN void
1028	SWIG_Python_SetErrorObj(PyObject errtype, PyObject obj) {
1029	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1030	PyErr_SetObject(errtype, obj);
1031	Py_DECREF(obj);
1032	SWIG_PYTHON_THREAD_END_BLOCK;
1033	}
1034
1035	SWIGINTERN void
1036	SWIG_Python_SetErrorMsg(PyObject errtype, const char msg) {
1037	SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038	PyErr_SetString(errtype, (char *) msg);
1039	SWIG_PYTHON_THREAD_END_BLOCK;
1040	}
1041
1042	#define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1043
1044	/* Set a constant value */
1045
1046	SWIGINTERN void
1047	SWIG_Python_SetConstant(PyObject d, const char name, PyObject *obj) {
1048	PyDict_SetItemString(d, (char*) name, obj);
1049	Py_DECREF(obj);
1050	}
1051
1052	/* Append a value to the result obj */
1053
1054	SWIGINTERN PyObject*
1055	SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1056	#if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1057	if (!result) {
1058	result = obj;
1059	} else if (result == Py_None) {
1060	Py_DECREF(result);
1061	result = obj;
1062	} else {
1063	if (!PyList_Check(result)) {
1064	PyObject *o2 = result;
1065	result = PyList_New(1);
1066	PyList_SetItem(result, 0, o2);
1067	}
1068	PyList_Append(result,obj);
1069	Py_DECREF(obj);
1070	}
1071	return result;
1072	#else
1073	PyObject* o2;
1074	PyObject* o3;
1075	if (!result) {
1076	result = obj;
1077	} else if (result == Py_None) {
1078	Py_DECREF(result);
1079	result = obj;
1080	} else {
1081	if (!PyTuple_Check(result)) {
1082	o2 = result;
1083	result = PyTuple_New(1);
1084	PyTuple_SET_ITEM(result, 0, o2);
1085	}
1086	o3 = PyTuple_New(1);
1087	PyTuple_SET_ITEM(o3, 0, obj);
1088	o2 = result;
1089	result = PySequence_Concat(o2, o3);
1090	Py_DECREF(o2);
1091	Py_DECREF(o3);
1092	}
1093	return result;
1094	#endif
1095	}
1096
1097	/* Unpack the argument tuple */
1098
1099	SWIGINTERN int
1100	SWIG_Python_UnpackTuple(PyObject args, const char name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1101	{
1102	if (!args) {
1103	if (!min && !max) {
1104	return 1;
1105	} else {
1106	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1107	name, (min == max ? "" : "at least "), (int)min);
1108	return 0;
1109	}
1110	}
1111	if (!PyTuple_Check(args)) {
1112	PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1113	return 0;
1114	} else {
1115	register Py_ssize_t l = PyTuple_GET_SIZE(args);
1116	if (l < min) {
1117	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1118	name, (min == max ? "" : "at least "), (int)min, (int)l);
1119	return 0;
1120	} else if (l > max) {
1121	PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1122	name, (min == max ? "" : "at most "), (int)max, (int)l);
1123	return 0;
1124	} else {
1125	register int i;
1126	for (i = 0; i < l; ++i) {
1127	objs[i] = PyTuple_GET_ITEM(args, i);
1128	}
1129	for (; l < max; ++l) {
1130	objs[l] = 0;
1131	}
1132	return i + 1;
1133	}
1134	}
1135	}
1136
1137	/* A functor is a function object with one single object argument */
1138	#if PY_VERSION_HEX >= 0x02020000
1139	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1140	#else
1141	#define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1142	#endif
1143
1144	/*
1145	Helper for static pointer initialization for both C and C++ code, for example
1146	static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1147	*/
1148	#ifdef __cplusplus
1149	#define SWIG_STATIC_POINTER(var) var
1150	#else
1151	#define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1152	#endif
1153
1154	/* -----------------------------------------------------------------------------
1155	* Pointer declarations
1156	* ----------------------------------------------------------------------------- */
1157
1158	/* Flags for new pointer objects */
1159	#define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1160	#define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW \| SWIG_POINTER_OWN)
1161
1162	#define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1163
1164	#ifdef __cplusplus
1165	extern "C" {
1166	#if 0
1167	} /* cc-mode */
1168	#endif
1169	#endif
1170
1171	/* How to access Py_None */
1172	#if defined(_WIN32) \|\| defined(__WIN32__) \|\| defined(__CYGWIN__)
1173	# ifndef SWIG_PYTHON_NO_BUILD_NONE
1174	# ifndef SWIG_PYTHON_BUILD_NONE
1175	# define SWIG_PYTHON_BUILD_NONE
1176	# endif
1177	# endif
1178	#endif
1179
1180	#ifdef SWIG_PYTHON_BUILD_NONE
1181	# ifdef Py_None
1182	# undef Py_None
1183	# define Py_None SWIG_Py_None()
1184	# endif
1185	SWIGRUNTIMEINLINE PyObject *
1186	_SWIG_Py_None(void)
1187	{
1188	PyObject none = Py_BuildValue((char)"");
1189	Py_DECREF(none);
1190	return none;
1191	}
1192	SWIGRUNTIME PyObject *
1193	SWIG_Py_None(void)
1194	{
1195	static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1196	return none;
1197	}
1198	#endif
1199
1200	/* The python void return value */
1201
1202	SWIGRUNTIMEINLINE PyObject *
1203	SWIG_Py_Void(void)
1204	{
1205	PyObject *none = Py_None;
1206	Py_INCREF(none);
1207	return none;
1208	}
1209
1210	/* PySwigClientData */
1211
1212	typedef struct {
1213	PyObject *klass;
1214	PyObject *newraw;
1215	PyObject *newargs;
1216	PyObject *destroy;
1217	int delargs;
1218	int implicitconv;
1219	} PySwigClientData;
1220
1221	SWIGRUNTIMEINLINE int
1222	SWIG_Python_CheckImplicit(swig_type_info *ty)
1223	{
1224	PySwigClientData data = (PySwigClientData )ty->clientdata;
1225	return data ? data->implicitconv : 0;
1226	}
1227
1228	SWIGRUNTIMEINLINE PyObject *
1229	SWIG_Python_ExceptionType(swig_type_info *desc) {
1230	PySwigClientData data = desc ? (PySwigClientData ) desc->clientdata : 0;
1231	PyObject *klass = data ? data->klass : 0;
1232	return (klass ? klass : PyExc_RuntimeError);
1233	}
1234
1235
1236	SWIGRUNTIME PySwigClientData *
1237	PySwigClientData_New(PyObject* obj)
1238	{
1239	if (!obj) {
1240	return 0;
1241	} else {
1242	PySwigClientData data = (PySwigClientData )malloc(sizeof(PySwigClientData));
1243	/* the klass element */
1244	data->klass = obj;
1245	Py_INCREF(data->klass);
1246	/* the newraw method and newargs arguments used to create a new raw instance */
1247	if (PyClass_Check(obj)) {
1248	data->newraw = 0;
1249	data->newargs = obj;
1250	Py_INCREF(obj);
1251	} else {
1252	#if (PY_VERSION_HEX < 0x02020000)
1253	data->newraw = 0;
1254	#else
1255	data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1256	#endif
1257	if (data->newraw) {
1258	Py_INCREF(data->newraw);
1259	data->newargs = PyTuple_New(1);
1260	PyTuple_SetItem(data->newargs, 0, obj);
1261	} else {
1262	data->newargs = obj;
1263	}
1264	Py_INCREF(data->newargs);
1265	}
1266	/* the destroy method, aka as the C++ delete method */
1267	data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1268	if (PyErr_Occurred()) {
1269	PyErr_Clear();
1270	data->destroy = 0;
1271	}
1272	if (data->destroy) {
1273	int flags;
1274	Py_INCREF(data->destroy);
1275	flags = PyCFunction_GET_FLAGS(data->destroy);
1276	#ifdef METH_O
1277	data->delargs = !(flags & (METH_O));
1278	#else
1279	data->delargs = 0;
1280	#endif
1281	} else {
1282	data->delargs = 0;
1283	}
1284	data->implicitconv = 0;
1285	return data;
1286	}
1287	}
1288
1289	SWIGRUNTIME void
1290	PySwigClientData_Del(PySwigClientData* data)
1291	{
1292	Py_XDECREF(data->newraw);
1293	Py_XDECREF(data->newargs);
1294	Py_XDECREF(data->destroy);
1295	}
1296
1297	/* =============== PySwigObject =====================*/
1298
1299	typedef struct {
1300	PyObject_HEAD
1301	void *ptr;
1302	swig_type_info *ty;
1303	int own;
1304	PyObject *next;
1305	} PySwigObject;
1306
1307	SWIGRUNTIME PyObject *
1308	PySwigObject_long(PySwigObject *v)
1309	{
1310	return PyLong_FromVoidPtr(v->ptr);
1311	}
1312
1313	SWIGRUNTIME PyObject *
1314	PySwigObject_format(const char* fmt, PySwigObject *v)
1315	{
1316	PyObject *res = NULL;
1317	PyObject *args = PyTuple_New(1);
1318	if (args) {
1319	if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1320	PyObject *ofmt = PyString_FromString(fmt);
1321	if (ofmt) {
1322	res = PyString_Format(ofmt,args);
1323	Py_DECREF(ofmt);
1324	}
1325	Py_DECREF(args);
1326	}
1327	}
1328	return res;
1329	}
1330
1331	SWIGRUNTIME PyObject *
1332	PySwigObject_oct(PySwigObject *v)
1333	{
1334	return PySwigObject_format("%o",v);
1335	}
1336
1337	SWIGRUNTIME PyObject *
1338	PySwigObject_hex(PySwigObject *v)
1339	{
1340	return PySwigObject_format("%x",v);
1341	}
1342
1343	SWIGRUNTIME PyObject *
1344	#ifdef METH_NOARGS
1345	PySwigObject_repr(PySwigObject *v)
1346	#else
1347	PySwigObject_repr(PySwigObject v, PyObject args)
1348	#endif
1349	{
1350	const char *name = SWIG_TypePrettyName(v->ty);
1351	PyObject *hex = PySwigObject_hex(v);
1352	PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1353	Py_DECREF(hex);
1354	if (v->next) {
1355	#ifdef METH_NOARGS
1356	PyObject nrep = PySwigObject_repr((PySwigObject )v->next);
1357	#else
1358	PyObject nrep = PySwigObject_repr((PySwigObject )v->next, args);
1359	#endif
1360	PyString_ConcatAndDel(&repr,nrep);
1361	}
1362	return repr;
1363	}
1364
1365	SWIGRUNTIME int
1366	PySwigObject_print(PySwigObject v, FILE fp, int SWIGUNUSEDPARM(flags))
1367	{
1368	#ifdef METH_NOARGS
1369	PyObject *repr = PySwigObject_repr(v);
1370	#else
1371	PyObject *repr = PySwigObject_repr(v, NULL);
1372	#endif
1373	if (repr) {
1374	fputs(PyString_AsString(repr), fp);
1375	Py_DECREF(repr);
1376	return 0;
1377	} else {
1378	return 1;
1379	}
1380	}
1381
1382	SWIGRUNTIME PyObject *
1383	PySwigObject_str(PySwigObject *v)
1384	{
1385	char result[SWIG_BUFFER_SIZE];
1386	return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1387	PyString_FromString(result) : 0;
1388	}
1389
1390	SWIGRUNTIME int
1391	PySwigObject_compare(PySwigObject v, PySwigObject w)
1392	{
1393	void *i = v->ptr;
1394	void *j = w->ptr;
1395	return (i < j) ? -1 : ((i > j) ? 1 : 0);
1396	}
1397
1398	SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1399
1400	SWIGRUNTIME PyTypeObject*
1401	PySwigObject_type(void) {
1402	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1403	return type;
1404	}
1405
1406	SWIGRUNTIMEINLINE int
1407	PySwigObject_Check(PyObject *op) {
1408	return ((op)->ob_type == PySwigObject_type())
1409	\|\| (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1410	}
1411
1412	SWIGRUNTIME PyObject *
1413	PySwigObject_New(void ptr, swig_type_info ty, int own);
1414
1415	SWIGRUNTIME void
1416	PySwigObject_dealloc(PyObject *v)
1417	{
1418	PySwigObject sobj = (PySwigObject ) v;
1419	PyObject *next = sobj->next;
1420	if (sobj->own == SWIG_POINTER_OWN) {
1421	swig_type_info *ty = sobj->ty;
1422	PySwigClientData data = ty ? (PySwigClientData ) ty->clientdata : 0;
1423	PyObject *destroy = data ? data->destroy : 0;
1424	if (destroy) {
1425	/* destroy is always a VARARGS method */
1426	PyObject *res;
1427	if (data->delargs) {
1428	/* we need to create a temporal object to carry the destroy operation */
1429	PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1430	res = SWIG_Python_CallFunctor(destroy, tmp);
1431	Py_DECREF(tmp);
1432	} else {
1433	PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1434	PyObject *mself = PyCFunction_GET_SELF(destroy);
1435	res = ((*meth)(mself, v));
1436	}
1437	Py_XDECREF(res);
1438	}
1439	#if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1440	else {
1441	const char *name = SWIG_TypePrettyName(ty);
1442	printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1443	}
1444	#endif
1445	}
1446	Py_XDECREF(next);
1447	PyObject_DEL(v);
1448	}
1449
1450	SWIGRUNTIME PyObject*
1451	PySwigObject_append(PyObject* v, PyObject* next)
1452	{
1453	PySwigObject sobj = (PySwigObject ) v;
1454	#ifndef METH_O
1455	PyObject *tmp = 0;
1456	if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1457	next = tmp;
1458	#endif
1459	if (!PySwigObject_Check(next)) {
1460	return NULL;
1461	}
1462	sobj->next = next;
1463	Py_INCREF(next);
1464	return SWIG_Py_Void();
1465	}
1466
1467	SWIGRUNTIME PyObject*
1468	#ifdef METH_NOARGS
1469	PySwigObject_next(PyObject* v)
1470	#else
1471	PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1472	#endif
1473	{
1474	PySwigObject sobj = (PySwigObject ) v;
1475	if (sobj->next) {
1476	Py_INCREF(sobj->next);
1477	return sobj->next;
1478	} else {
1479	return SWIG_Py_Void();
1480	}
1481	}
1482
1483	SWIGINTERN PyObject*
1484	#ifdef METH_NOARGS
1485	PySwigObject_disown(PyObject *v)
1486	#else
1487	PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1488	#endif
1489	{
1490	PySwigObject sobj = (PySwigObject )v;
1491	sobj->own = 0;
1492	return SWIG_Py_Void();
1493	}
1494
1495	SWIGINTERN PyObject*
1496	#ifdef METH_NOARGS
1497	PySwigObject_acquire(PyObject *v)
1498	#else
1499	PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1500	#endif
1501	{
1502	PySwigObject sobj = (PySwigObject )v;
1503	sobj->own = SWIG_POINTER_OWN;
1504	return SWIG_Py_Void();
1505	}
1506
1507	SWIGINTERN PyObject*
1508	PySwigObject_own(PyObject v, PyObject args)
1509	{
1510	PyObject *val = 0;
1511	#if (PY_VERSION_HEX < 0x02020000)
1512	if (!PyArg_ParseTuple(args,(char *)"\|O:own",&val))
1513	#else
1514	if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1515	#endif
1516	{
1517	return NULL;
1518	}
1519	else
1520	{
1521	PySwigObject sobj = (PySwigObject )v;
1522	PyObject *obj = PyBool_FromLong(sobj->own);
1523	if (val) {
1524	#ifdef METH_NOARGS
1525	if (PyObject_IsTrue(val)) {
1526	PySwigObject_acquire(v);
1527	} else {
1528	PySwigObject_disown(v);
1529	}
1530	#else
1531	if (PyObject_IsTrue(val)) {
1532	PySwigObject_acquire(v,args);
1533	} else {
1534	PySwigObject_disown(v,args);
1535	}
1536	#endif
1537	}
1538	return obj;
1539	}
1540	}
1541
1542	#ifdef METH_O
1543	static PyMethodDef
1544	swigobject_methods[] = {
1545	{(char )"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char )"releases ownership of the pointer"},
1546	{(char )"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char )"aquires ownership of the pointer"},
1547	{(char )"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1548	{(char )"append", (PyCFunction)PySwigObject_append, METH_O, (char )"appends another 'this' object"},
1549	{(char )"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char )"returns the next 'this' object"},
1550	{(char )"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char )"returns object representation"},
1551	{0, 0, 0, 0}
1552	};
1553	#else
1554	static PyMethodDef
1555	swigobject_methods[] = {
1556	{(char )"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char )"releases ownership of the pointer"},
1557	{(char )"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char )"aquires ownership of the pointer"},
1558	{(char )"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char )"returns/sets ownership of the pointer"},
1559	{(char )"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char )"appends another 'this' object"},
1560	{(char )"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char )"returns the next 'this' object"},
1561	{(char )"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char )"returns object representation"},
1562	{0, 0, 0, 0}
1563	};
1564	#endif
1565
1566	#if PY_VERSION_HEX < 0x02020000
1567	SWIGINTERN PyObject *
1568	PySwigObject_getattr(PySwigObject sobj,char name)
1569	{
1570	return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1571	}
1572	#endif
1573
1574	SWIGRUNTIME PyTypeObject*
1575	_PySwigObject_type(void) {
1576	static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1577
1578	static PyNumberMethods PySwigObject_as_number = {
1579	(binaryfunc)0, /nb_add/
1580	(binaryfunc)0, /nb_subtract/
1581	(binaryfunc)0, /nb_multiply/
1582	(binaryfunc)0, /nb_divide/
1583	(binaryfunc)0, /nb_remainder/
1584	(binaryfunc)0, /nb_divmod/
1585	(ternaryfunc)0,/nb_power/
1586	(unaryfunc)0, /nb_negative/
1587	(unaryfunc)0, /nb_positive/
1588	(unaryfunc)0, /nb_absolute/
1589	(inquiry)0, /nb_nonzero/
1590	0, /nb_invert/
1591	0, /nb_lshift/
1592	0, /nb_rshift/
1593	0, /nb_and/
1594	0, /nb_xor/
1595	0, /nb_or/
1596	(coercion)0, /nb_coerce/
1597	(unaryfunc)PySwigObject_long, /nb_int/
1598	(unaryfunc)PySwigObject_long, /nb_long/
1599	(unaryfunc)0, /nb_float/
1600	(unaryfunc)PySwigObject_oct, /nb_oct/
1601	(unaryfunc)PySwigObject_hex, /nb_hex/
1602	#if PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1603	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1604	#elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1605	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1606	#elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1607	0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1608	#endif
1609	};
1610
1611	static PyTypeObject pyswigobject_type;
1612	static int type_init = 0;
1613	if (!type_init) {
1614	const PyTypeObject tmp
1615	= {
1616	PyObject_HEAD_INIT(NULL)
1617	0, /* ob_size */
1618	(char )"PySwigObject", / tp_name */
1619	sizeof(PySwigObject), /* tp_basicsize */
1620	0, /* tp_itemsize */
1621	(destructor)PySwigObject_dealloc, /* tp_dealloc */
1622	(printfunc)PySwigObject_print, /* tp_print */
1623	#if PY_VERSION_HEX < 0x02020000
1624	(getattrfunc)PySwigObject_getattr, /* tp_getattr */
1625	#else
1626	(getattrfunc)0, /* tp_getattr */
1627	#endif
1628	(setattrfunc)0, /* tp_setattr */
1629	(cmpfunc)PySwigObject_compare, /* tp_compare */
1630	(reprfunc)PySwigObject_repr, /* tp_repr */
1631	&PySwigObject_as_number, /* tp_as_number */
1632	0, /* tp_as_sequence */
1633	0, /* tp_as_mapping */
1634	(hashfunc)0, /* tp_hash */
1635	(ternaryfunc)0, /* tp_call */
1636	(reprfunc)PySwigObject_str, /* tp_str */
1637	PyObject_GenericGetAttr, /* tp_getattro */
1638	0, /* tp_setattro */
1639	0, /* tp_as_buffer */
1640	Py_TPFLAGS_DEFAULT, /* tp_flags */
1641	swigobject_doc, /* tp_doc */
1642	0, /* tp_traverse */
1643	0, /* tp_clear */
1644	0, /* tp_richcompare */
1645	0, /* tp_weaklistoffset */
1646	#if PY_VERSION_HEX >= 0x02020000
1647	0, /* tp_iter */
1648	0, /* tp_iternext */
1649	swigobject_methods, /* tp_methods */
1650	0, /* tp_members */
1651	0, /* tp_getset */
1652	0, /* tp_base */
1653	0, /* tp_dict */
1654	0, /* tp_descr_get */
1655	0, /* tp_descr_set */
1656	0, /* tp_dictoffset */
1657	0, /* tp_init */
1658	0, /* tp_alloc */
1659	0, /* tp_new */
1660	0, /* tp_free */
1661	0, /* tp_is_gc */
1662	0, /* tp_bases */
1663	0, /* tp_mro */
1664	0, /* tp_cache */
1665	0, /* tp_subclasses */
1666	0, /* tp_weaklist */
1667	#endif
1668	#if PY_VERSION_HEX >= 0x02030000
1669	0, /* tp_del */
1670	#endif
1671	#ifdef COUNT_ALLOCS
1672	0,0,0,0 /* tp_alloc -> tp_next */
1673	#endif
1674	};
1675	pyswigobject_type = tmp;
1676	pyswigobject_type.ob_type = &PyType_Type;
1677	type_init = 1;
1678	}
1679	return &pyswigobject_type;
1680	}
1681
1682	SWIGRUNTIME PyObject *
1683	PySwigObject_New(void ptr, swig_type_info ty, int own)
1684	{
1685	PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1686	if (sobj) {
1687	sobj->ptr = ptr;
1688	sobj->ty = ty;
1689	sobj->own = own;
1690	sobj->next = 0;
1691	}
1692	return (PyObject *)sobj;
1693	}
1694
1695	/* -----------------------------------------------------------------------------
1696	* Implements a simple Swig Packed type, and use it instead of string
1697	* ----------------------------------------------------------------------------- */
1698
1699	typedef struct {
1700	PyObject_HEAD
1701	void *pack;
1702	swig_type_info *ty;
1703	size_t size;
1704	} PySwigPacked;
1705
1706	SWIGRUNTIME int
1707	PySwigPacked_print(PySwigPacked v, FILE fp, int SWIGUNUSEDPARM(flags))
1708	{
1709	char result[SWIG_BUFFER_SIZE];
1710	fputs("<Swig Packed ", fp);
1711	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1712	fputs("at ", fp);
1713	fputs(result, fp);
1714	}
1715	fputs(v->ty->name,fp);
1716	fputs(">", fp);
1717	return 0;
1718	}
1719
1720	SWIGRUNTIME PyObject *
1721	PySwigPacked_repr(PySwigPacked *v)
1722	{
1723	char result[SWIG_BUFFER_SIZE];
1724	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1725	return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1726	} else {
1727	return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1728	}
1729	}
1730
1731	SWIGRUNTIME PyObject *
1732	PySwigPacked_str(PySwigPacked *v)
1733	{
1734	char result[SWIG_BUFFER_SIZE];
1735	if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1736	return PyString_FromFormat("%s%s", result, v->ty->name);
1737	} else {
1738	return PyString_FromString(v->ty->name);
1739	}
1740	}
1741
1742	SWIGRUNTIME int
1743	PySwigPacked_compare(PySwigPacked v, PySwigPacked w)
1744	{
1745	size_t i = v->size;
1746	size_t j = w->size;
1747	int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1748	return s ? s : strncmp((char )v->pack, (char )w->pack, 2*v->size);
1749	}
1750
1751	SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1752
1753	SWIGRUNTIME PyTypeObject*
1754	PySwigPacked_type(void) {
1755	static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1756	return type;
1757	}
1758
1759	SWIGRUNTIMEINLINE int
1760	PySwigPacked_Check(PyObject *op) {
1761	return ((op)->ob_type == _PySwigPacked_type())
1762	\|\| (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1763	}
1764
1765	SWIGRUNTIME void
1766	PySwigPacked_dealloc(PyObject *v)
1767	{
1768	if (PySwigPacked_Check(v)) {
1769	PySwigPacked sobj = (PySwigPacked ) v;
1770	free(sobj->pack);
1771	}
1772	PyObject_DEL(v);
1773	}
1774
1775	SWIGRUNTIME PyTypeObject*
1776	_PySwigPacked_type(void) {
1777	static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1778	static PyTypeObject pyswigpacked_type;
1779	static int type_init = 0;
1780	if (!type_init) {
1781	const PyTypeObject tmp
1782	= {
1783	PyObject_HEAD_INIT(NULL)
1784	0, /* ob_size */
1785	(char )"PySwigPacked", / tp_name */
1786	sizeof(PySwigPacked), /* tp_basicsize */
1787	0, /* tp_itemsize */
1788	(destructor)PySwigPacked_dealloc, /* tp_dealloc */
1789	(printfunc)PySwigPacked_print, /* tp_print */
1790	(getattrfunc)0, /* tp_getattr */
1791	(setattrfunc)0, /* tp_setattr */
1792	(cmpfunc)PySwigPacked_compare, /* tp_compare */
1793	(reprfunc)PySwigPacked_repr, /* tp_repr */
1794	0, /* tp_as_number */
1795	0, /* tp_as_sequence */
1796	0, /* tp_as_mapping */
1797	(hashfunc)0, /* tp_hash */
1798	(ternaryfunc)0, /* tp_call */
1799	(reprfunc)PySwigPacked_str, /* tp_str */
1800	PyObject_GenericGetAttr, /* tp_getattro */
1801	0, /* tp_setattro */
1802	0, /* tp_as_buffer */
1803	Py_TPFLAGS_DEFAULT, /* tp_flags */
1804	swigpacked_doc, /* tp_doc */
1805	0, /* tp_traverse */
1806	0, /* tp_clear */
1807	0, /* tp_richcompare */
1808	0, /* tp_weaklistoffset */
1809	#if PY_VERSION_HEX >= 0x02020000
1810	0, /* tp_iter */
1811	0, /* tp_iternext */
1812	0, /* tp_methods */
1813	0, /* tp_members */
1814	0, /* tp_getset */
1815	0, /* tp_base */
1816	0, /* tp_dict */
1817	0, /* tp_descr_get */
1818	0, /* tp_descr_set */
1819	0, /* tp_dictoffset */
1820	0, /* tp_init */
1821	0, /* tp_alloc */
1822	0, /* tp_new */
1823	0, /* tp_free */
1824	0, /* tp_is_gc */
1825	0, /* tp_bases */
1826	0, /* tp_mro */
1827	0, /* tp_cache */
1828	0, /* tp_subclasses */
1829	0, /* tp_weaklist */
1830	#endif
1831	#if PY_VERSION_HEX >= 0x02030000
1832	0, /* tp_del */
1833	#endif
1834	#ifdef COUNT_ALLOCS
1835	0,0,0,0 /* tp_alloc -> tp_next */
1836	#endif
1837	};
1838	pyswigpacked_type = tmp;
1839	pyswigpacked_type.ob_type = &PyType_Type;
1840	type_init = 1;
1841	}
1842	return &pyswigpacked_type;
1843	}
1844
1845	SWIGRUNTIME PyObject *
1846	PySwigPacked_New(void ptr, size_t size, swig_type_info ty)
1847	{
1848	PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1849	if (sobj) {
1850	void *pack = malloc(size);
1851	if (pack) {
1852	memcpy(pack, ptr, size);
1853	sobj->pack = pack;
1854	sobj->ty = ty;
1855	sobj->size = size;
1856	} else {
1857	PyObject_DEL((PyObject *) sobj);
1858	sobj = 0;
1859	}
1860	}
1861	return (PyObject *) sobj;
1862	}
1863
1864	SWIGRUNTIME swig_type_info *
1865	PySwigPacked_UnpackData(PyObject obj, void ptr, size_t size)
1866	{
1867	if (PySwigPacked_Check(obj)) {
1868	PySwigPacked sobj = (PySwigPacked )obj;
1869	if (sobj->size != size) return 0;
1870	memcpy(ptr, sobj->pack, size);
1871	return sobj->ty;
1872	} else {
1873	return 0;
1874	}
1875	}
1876
1877	/* -----------------------------------------------------------------------------
1878	* pointers/data manipulation
1879	* ----------------------------------------------------------------------------- */
1880
1881	SWIGRUNTIMEINLINE PyObject *
1882	_SWIG_This(void)
1883	{
1884	return PyString_FromString("this");
1885	}
1886
1887	SWIGRUNTIME PyObject *
1888	SWIG_This(void)
1889	{
1890	static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1891	return swig_this;
1892	}
1893
1894	/* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1895
1896	SWIGRUNTIME PySwigObject *
1897	SWIG_Python_GetSwigThis(PyObject *pyobj)
1898	{
1899	if (PySwigObject_Check(pyobj)) {
1900	return (PySwigObject *) pyobj;
1901	} else {
1902	PyObject *obj = 0;
1903	#if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1904	if (PyInstance_Check(pyobj)) {
1905	obj = _PyInstance_Lookup(pyobj, SWIG_This());
1906	} else {
1907	PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1908	if (dictptr != NULL) {
1909	PyObject dict = dictptr;
1910	obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1911	} else {
1912	#ifdef PyWeakref_CheckProxy
1913	if (PyWeakref_CheckProxy(pyobj)) {
1914	PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1915	return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1916	}
1917	#endif
1918	obj = PyObject_GetAttr(pyobj,SWIG_This());
1919	if (obj) {
1920	Py_DECREF(obj);
1921	} else {
1922	if (PyErr_Occurred()) PyErr_Clear();
1923	return 0;
1924	}
1925	}
1926	}
1927	#else
1928	obj = PyObject_GetAttr(pyobj,SWIG_This());
1929	if (obj) {
1930	Py_DECREF(obj);
1931	} else {
1932	if (PyErr_Occurred()) PyErr_Clear();
1933	return 0;
1934	}
1935	#endif
1936	if (obj && !PySwigObject_Check(obj)) {
1937	/* a PyObject is called 'this', try to get the 'real this'
1938	PySwigObject from it */
1939	return SWIG_Python_GetSwigThis(obj);
1940	}
1941	return (PySwigObject *)obj;
1942	}
1943	}
1944
1945	/* Acquire a pointer value */
1946
1947	SWIGRUNTIME int
1948	SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1949	if (own == SWIG_POINTER_OWN) {
1950	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1951	if (sobj) {
1952	int oldown = sobj->own;
1953	sobj->own = own;
1954	return oldown;
1955	}
1956	}
1957	return 0;
1958	}
1959
1960	/* Convert a pointer value */
1961
1962	SWIGRUNTIME int
1963	SWIG_Python_ConvertPtrAndOwn(PyObject obj, void ptr, swig_type_info ty, int flags, int *own) {
1964	if (!obj) return SWIG_ERROR;
1965	if (obj == Py_None) {
1966	if (ptr) *ptr = 0;
1967	return SWIG_OK;
1968	} else {
1969	PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1970	if (own)
1971	*own = 0;
1972	while (sobj) {
1973	void *vptr = sobj->ptr;
1974	if (ty) {
1975	swig_type_info *to = sobj->ty;
1976	if (to == ty) {
1977	/* no type cast needed */
1978	if (ptr) *ptr = vptr;
1979	break;
1980	} else {
1981	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1982	if (!tc) {
1983	sobj = (PySwigObject *)sobj->next;
1984	} else {
1985	if (ptr) {
1986	int newmemory = 0;
1987	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
1988	if (newmemory == SWIG_CAST_NEW_MEMORY) {
1989	assert(own);
1990	if (own)
1991	own = own \| SWIG_CAST_NEW_MEMORY;
1992	}
1993	}
1994	break;
1995	}
1996	}
1997	} else {
1998	if (ptr) *ptr = vptr;
1999	break;
2000	}
2001	}
2002	if (sobj) {
2003	if (own)
2004	own = own \| sobj->own;
2005	if (flags & SWIG_POINTER_DISOWN) {
2006	sobj->own = 0;
2007	}
2008	return SWIG_OK;
2009	} else {
2010	int res = SWIG_ERROR;
2011	if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2012	PySwigClientData data = ty ? (PySwigClientData ) ty->clientdata : 0;
2013	if (data && !data->implicitconv) {
2014	PyObject *klass = data->klass;
2015	if (klass) {
2016	PyObject *impconv;
2017	data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2018	impconv = SWIG_Python_CallFunctor(klass, obj);
2019	data->implicitconv = 0;
2020	if (PyErr_Occurred()) {
2021	PyErr_Clear();
2022	impconv = 0;
2023	}
2024	if (impconv) {
2025	PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2026	if (iobj) {
2027	void *vptr;
2028	res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2029	if (SWIG_IsOK(res)) {
2030	if (ptr) {
2031	*ptr = vptr;
2032	/* transfer the ownership to 'ptr' */
2033	iobj->own = 0;
2034	res = SWIG_AddCast(res);
2035	res = SWIG_AddNewMask(res);
2036	} else {
2037	res = SWIG_AddCast(res);
2038	}
2039	}
2040	}
2041	Py_DECREF(impconv);
2042	}
2043	}
2044	}
2045	}
2046	return res;
2047	}
2048	}
2049	}
2050
2051	/* Convert a function ptr value */
2052
2053	SWIGRUNTIME int
2054	SWIG_Python_ConvertFunctionPtr(PyObject obj, void ptr, swig_type_info ty) {
2055	if (!PyCFunction_Check(obj)) {
2056	return SWIG_ConvertPtr(obj, ptr, ty, 0);
2057	} else {
2058	void *vptr = 0;
2059
2060	/* here we get the method pointer for callbacks */
2061	const char doc = (((PyCFunctionObject )obj) -> m_ml -> ml_doc);
2062	const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2063	if (desc) {
2064	desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2065	if (!desc) return SWIG_ERROR;
2066	}
2067	if (ty) {
2068	swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2069	if (tc) {
2070	int newmemory = 0;
2071	*ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2072	assert(!newmemory); /* newmemory handling not yet implemented */
2073	} else {
2074	return SWIG_ERROR;
2075	}
2076	} else {
2077	*ptr = vptr;
2078	}
2079	return SWIG_OK;
2080	}
2081	}
2082
2083	/* Convert a packed value value */
2084
2085	SWIGRUNTIME int
2086	SWIG_Python_ConvertPacked(PyObject obj, void ptr, size_t sz, swig_type_info *ty) {
2087	swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2088	if (!to) return SWIG_ERROR;
2089	if (ty) {
2090	if (to != ty) {
2091	/* check type cast? */
2092	swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2093	if (!tc) return SWIG_ERROR;
2094	}
2095	}
2096	return SWIG_OK;
2097	}
2098
2099	/* -----------------------------------------------------------------------------
2100	* Create a new pointer object
2101	* ----------------------------------------------------------------------------- */
2102
2103	/*
2104	Create a new instance object, whitout calling __init__, and set the
2105	'this' attribute.
2106	*/
2107
2108	SWIGRUNTIME PyObject*
2109	SWIG_Python_NewShadowInstance(PySwigClientData data, PyObject swig_this)
2110	{
2111	#if (PY_VERSION_HEX >= 0x02020000)
2112	PyObject *inst = 0;
2113	PyObject *newraw = data->newraw;
2114	if (newraw) {
2115	inst = PyObject_Call(newraw, data->newargs, NULL);
2116	if (inst) {
2117	#if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2118	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2119	if (dictptr != NULL) {
2120	PyObject dict = dictptr;
2121	if (dict == NULL) {
2122	dict = PyDict_New();
2123	*dictptr = dict;
2124	PyDict_SetItem(dict, SWIG_This(), swig_this);
2125	}
2126	}
2127	#else
2128	PyObject *key = SWIG_This();
2129	PyObject_SetAttr(inst, key, swig_this);
2130	#endif
2131	}
2132	} else {
2133	PyObject *dict = PyDict_New();
2134	PyDict_SetItem(dict, SWIG_This(), swig_this);
2135	inst = PyInstance_NewRaw(data->newargs, dict);
2136	Py_DECREF(dict);
2137	}
2138	return inst;
2139	#else
2140	#if (PY_VERSION_HEX >= 0x02010000)
2141	PyObject *inst;
2142	PyObject *dict = PyDict_New();
2143	PyDict_SetItem(dict, SWIG_This(), swig_this);
2144	inst = PyInstance_NewRaw(data->newargs, dict);
2145	Py_DECREF(dict);
2146	return (PyObject *) inst;
2147	#else
2148	PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2149	if (inst == NULL) {
2150	return NULL;
2151	}
2152	inst->in_class = (PyClassObject *)data->newargs;
2153	Py_INCREF(inst->in_class);
2154	inst->in_dict = PyDict_New();
2155	if (inst->in_dict == NULL) {
2156	Py_DECREF(inst);
2157	return NULL;
2158	}
2159	#ifdef Py_TPFLAGS_HAVE_WEAKREFS
2160	inst->in_weakreflist = NULL;
2161	#endif
2162	#ifdef Py_TPFLAGS_GC
2163	PyObject_GC_Init(inst);
2164	#endif
2165	PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2166	return (PyObject *) inst;
2167	#endif
2168	#endif
2169	}
2170
2171	SWIGRUNTIME void
2172	SWIG_Python_SetSwigThis(PyObject inst, PyObject swig_this)
2173	{
2174	PyObject *dict;
2175	#if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2176	PyObject **dictptr = _PyObject_GetDictPtr(inst);
2177	if (dictptr != NULL) {
2178	dict = *dictptr;
2179	if (dict == NULL) {
2180	dict = PyDict_New();
2181	*dictptr = dict;
2182	}
2183	PyDict_SetItem(dict, SWIG_This(), swig_this);
2184	return;
2185	}
2186	#endif
2187	dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2188	PyDict_SetItem(dict, SWIG_This(), swig_this);
2189	Py_DECREF(dict);
2190	}
2191
2192
2193	SWIGINTERN PyObject *
2194	SWIG_Python_InitShadowInstance(PyObject *args) {
2195	PyObject *obj[2];
2196	if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2197	return NULL;
2198	} else {
2199	PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2200	if (sthis) {
2201	PySwigObject_append((PyObject*) sthis, obj[1]);
2202	} else {
2203	SWIG_Python_SetSwigThis(obj[0], obj[1]);
2204	}
2205	return SWIG_Py_Void();
2206	}
2207	}
2208
2209	/* Create a new pointer object */
2210
2211	SWIGRUNTIME PyObject *
2212	SWIG_Python_NewPointerObj(void ptr, swig_type_info type, int flags) {
2213	if (!ptr) {
2214	return SWIG_Py_Void();
2215	} else {
2216	int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2217	PyObject *robj = PySwigObject_New(ptr, type, own);
2218	PySwigClientData clientdata = type ? (PySwigClientData )(type->clientdata) : 0;
2219	if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2220	PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2221	if (inst) {
2222	Py_DECREF(robj);
2223	robj = inst;
2224	}
2225	}
2226	return robj;
2227	}
2228	}
2229
2230	/* Create a new packed object */
2231
2232	SWIGRUNTIMEINLINE PyObject *
2233	SWIG_Python_NewPackedObj(void ptr, size_t sz, swig_type_info type) {
2234	return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2235	}
2236
2237	/* -----------------------------------------------------------------------------*
2238	* Get type list
2239	* -----------------------------------------------------------------------------*/
2240
2241	#ifdef SWIG_LINK_RUNTIME
2242	void SWIG_ReturnGlobalTypeList(void );
2243	#endif
2244
2245	SWIGRUNTIME swig_module_info *
2246	SWIG_Python_GetModule(void) {
2247	static void type_pointer = (void )0;
2248	/* first check if module already created */
2249	if (!type_pointer) {
2250	#ifdef SWIG_LINK_RUNTIME
2251	type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2252	#else
2253	type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2254	(char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2255	if (PyErr_Occurred()) {
2256	PyErr_Clear();
2257	type_pointer = (void *)0;
2258	}
2259	#endif
2260	}
2261	return (swig_module_info *) type_pointer;
2262	}
2263
2264	#if PY_MAJOR_VERSION < 2
2265	/* PyModule_AddObject function was introduced in Python 2.0. The following function
2266	is copied out of Python/modsupport.c in python version 2.3.4 */
2267	SWIGINTERN int
2268	PyModule_AddObject(PyObject m, char name, PyObject *o)
2269	{
2270	PyObject *dict;
2271	if (!PyModule_Check(m)) {
2272	PyErr_SetString(PyExc_TypeError,
2273	"PyModule_AddObject() needs module as first arg");
2274	return SWIG_ERROR;
2275	}
2276	if (!o) {
2277	PyErr_SetString(PyExc_TypeError,
2278	"PyModule_AddObject() needs non-NULL value");
2279	return SWIG_ERROR;
2280	}
2281
2282	dict = PyModule_GetDict(m);
2283	if (dict == NULL) {
2284	/* Internal error -- modules must have a dict! */
2285	PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2286	PyModule_GetName(m));
2287	return SWIG_ERROR;
2288	}
2289	if (PyDict_SetItemString(dict, name, o))
2290	return SWIG_ERROR;
2291	Py_DECREF(o);
2292	return SWIG_OK;
2293	}
2294	#endif
2295
2296	SWIGRUNTIME void
2297	SWIG_Python_DestroyModule(void *vptr)
2298	{
2299	swig_module_info swig_module = (swig_module_info ) vptr;
2300	swig_type_info **types = swig_module->types;
2301	size_t i;
2302	for (i =0; i < swig_module->size; ++i) {
2303	swig_type_info *ty = types[i];
2304	if (ty->owndata) {
2305	PySwigClientData data = (PySwigClientData ) ty->clientdata;
2306	if (data) PySwigClientData_Del(data);
2307	}
2308	}
2309	Py_DECREF(SWIG_This());
2310	}
2311
2312	SWIGRUNTIME void
2313	SWIG_Python_SetModule(swig_module_info *swig_module) {
2314	static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2315
2316	PyObject module = Py_InitModule((char)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2317	swig_empty_runtime_method_table);
2318	PyObject pointer = PyCObject_FromVoidPtr((void ) swig_module, SWIG_Python_DestroyModule);
2319	if (pointer && module) {
2320	PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2321	} else {
2322	Py_XDECREF(pointer);
2323	}
2324	}
2325
2326	/* The python cached type query */
2327	SWIGRUNTIME PyObject *
2328	SWIG_Python_TypeCache(void) {
2329	static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2330	return cache;
2331	}
2332
2333	SWIGRUNTIME swig_type_info *
2334	SWIG_Python_TypeQuery(const char *type)
2335	{
2336	PyObject *cache = SWIG_Python_TypeCache();
2337	PyObject *key = PyString_FromString(type);
2338	PyObject *obj = PyDict_GetItem(cache, key);
2339	swig_type_info *descriptor;
2340	if (obj) {
2341	descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2342	} else {
2343	swig_module_info *swig_module = SWIG_Python_GetModule();
2344	descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2345	if (descriptor) {
2346	obj = PyCObject_FromVoidPtr(descriptor, NULL);
2347	PyDict_SetItem(cache, key, obj);
2348	Py_DECREF(obj);
2349	}
2350	}
2351	Py_DECREF(key);
2352	return descriptor;
2353	}
2354
2355	/*
2356	For backward compatibility only
2357	*/
2358	#define SWIG_POINTER_EXCEPTION 0
2359	#define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2360	#define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2361
2362	SWIGRUNTIME int
2363	SWIG_Python_AddErrMesg(const char* mesg, int infront)
2364	{
2365	if (PyErr_Occurred()) {
2366	PyObject *type = 0;
2367	PyObject *value = 0;
2368	PyObject *traceback = 0;
2369	PyErr_Fetch(&type, &value, &traceback);
2370	if (value) {
2371	PyObject *old_str = PyObject_Str(value);
2372	Py_XINCREF(type);
2373	PyErr_Clear();
2374	if (infront) {
2375	PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2376	} else {
2377	PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2378	}
2379	Py_DECREF(old_str);
2380	}
2381	return 1;
2382	} else {
2383	return 0;
2384	}
2385	}
2386
2387	SWIGRUNTIME int
2388	SWIG_Python_ArgFail(int argnum)
2389	{
2390	if (PyErr_Occurred()) {
2391	/* add information about failing argument */
2392	char mesg[256];
2393	PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2394	return SWIG_Python_AddErrMesg(mesg, 1);
2395	} else {
2396	return 0;
2397	}
2398	}
2399
2400	SWIGRUNTIMEINLINE const char *
2401	PySwigObject_GetDesc(PyObject *self)
2402	{
2403	PySwigObject v = (PySwigObject )self;
2404	swig_type_info *ty = v ? v->ty : 0;
2405	return ty ? ty->str : (char*)"";
2406	}
2407
2408	SWIGRUNTIME void
2409	SWIG_Python_TypeError(const char type, PyObject obj)
2410	{
2411	if (type) {
2412	#if defined(SWIG_COBJECT_TYPES)
2413	if (obj && PySwigObject_Check(obj)) {
2414	const char otype = (const char ) PySwigObject_GetDesc(obj);
2415	if (otype) {
2416	PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2417	type, otype);
2418	return;
2419	}
2420	} else
2421	#endif
2422	{
2423	const char *otype = (obj ? obj->ob_type->tp_name : 0);
2424	if (otype) {
2425	PyObject *str = PyObject_Str(obj);
2426	const char *cstr = str ? PyString_AsString(str) : 0;
2427	if (cstr) {
2428	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2429	type, otype, cstr);
2430	} else {
2431	PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2432	type, otype);
2433	}
2434	Py_XDECREF(str);
2435	return;
2436	}
2437	}
2438	PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2439	} else {
2440	PyErr_Format(PyExc_TypeError, "unexpected type is received");
2441	}
2442	}
2443
2444
2445	/* Convert a pointer value, signal an exception on a type mismatch */
2446	SWIGRUNTIME void *
2447	SWIG_Python_MustGetPtr(PyObject obj, swig_type_info ty, int argnum, int flags) {
2448	void *result;
2449	if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2450	PyErr_Clear();
2451	if (flags & SWIG_POINTER_EXCEPTION) {
2452	SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2453	SWIG_Python_ArgFail(argnum);
2454	}
2455	}
2456	return result;
2457	}
2458
2459
2460	#ifdef __cplusplus
2461	#if 0
2462	{ /* cc-mode */
2463	#endif
2464	}
2465	#endif
2466
2467
2468
2469	#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2470
2471	#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2472
2473
2474
2475	/* -------- TYPES TABLE (BEGIN) -------- */
2476
2477	#define SWIGTYPE_p_TDB_DATA swig_types[0]
2478	#define SWIGTYPE_p_char swig_types[1]
2479	#define SWIGTYPE_p_int swig_types[2]
2480	#define SWIGTYPE_p_long_long swig_types[3]
2481	#define SWIGTYPE_p_short swig_types[4]
2482	#define SWIGTYPE_p_signed_char swig_types[5]
2483	#define SWIGTYPE_p_tdb_context swig_types[6]
2484	#define SWIGTYPE_p_unsigned_char swig_types[7]
2485	#define SWIGTYPE_p_unsigned_int swig_types[8]
2486	#define SWIGTYPE_p_unsigned_long_long swig_types[9]
2487	#define SWIGTYPE_p_unsigned_short swig_types[10]
2488	static swig_type_info *swig_types[12];
2489	static swig_module_info swig_module = {swig_types, 11, 0, 0, 0, 0};
2490	#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2491	#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2492
2493	/* -------- TYPES TABLE (END) -------- */
2494
2495	#if (PY_VERSION_HEX <= 0x02000000)
2496	# if !defined(SWIG_PYTHON_CLASSIC)
2497	# error "This python version requires swig to be run with the '-classic' option"
2498	# endif
2499	#endif
2500	#if (PY_VERSION_HEX <= 0x02020000)
2501	# error "This python version requires swig to be run with the '-nomodern' option"
2502	#endif
2503	#if (PY_VERSION_HEX <= 0x02020000)
2504	# error "This python version requires swig to be run with the '-nomodernargs' option"
2505	#endif
2506	#ifndef METH_O
2507	# error "This python version requires swig to be run with the '-nofastunpack' option"
2508	#endif
2509	#ifdef SWIG_TypeQuery
2510	# undef SWIG_TypeQuery
2511	#endif
2512	#define SWIG_TypeQuery SWIG_Python_TypeQuery
2513
2514	/*-----------------------------------------------
2515	@(target):= _tdb.so
2516	------------------------------------------------*/
2517	#define SWIG_init init_tdb
2518
2519	#define SWIG_name "_tdb"
2520
2521	#define SWIGVERSION 0x010335
2522	#define SWIG_VERSION SWIGVERSION
2523
2524
2525	#define SWIG_as_voidptr(a) (void )((const void )(a))
2526	#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(a),(void*)(a))
2527
2528
2529
2530	/* This symbol is used in both includes.h and Python.h which causes an
2531	annoying compiler warning. */
2532
2533	#ifdef HAVE_FSTAT
2534	#undef HAVE_FSTAT
2535	#endif
2536
2537	/* Include tdb headers */
2538	#include <stdint.h>
2539	#include <signal.h>
2540	#include <tdb.h>
2541	#include <fcntl.h>
2542
2543	typedef TDB_CONTEXT tdb;
2544
2545
2546	#define SWIG_From_long PyInt_FromLong
2547
2548
2549	SWIGINTERNINLINE PyObject *
2550	SWIG_From_int (int value)
2551	{
2552	return SWIG_From_long (value);
2553	}
2554
2555
2556	SWIGINTERN swig_type_info*
2557	SWIG_pchar_descriptor(void)
2558	{
2559	static int init = 0;
2560	static swig_type_info* info = 0;
2561	if (!init) {
2562	info = SWIG_TypeQuery("_p_char");
2563	init = 1;
2564	}
2565	return info;
2566	}
2567
2568
2569	SWIGINTERN int
2570	SWIG_AsCharPtrAndSize(PyObject obj, char* cptr, size_t* psize, int *alloc)
2571	{
2572	if (PyString_Check(obj)) {
2573	char *cstr; Py_ssize_t len;
2574	PyString_AsStringAndSize(obj, &cstr, &len);
2575	if (cptr) {
2576	if (alloc) {
2577	/*
2578	In python the user should not be able to modify the inner
2579	string representation. To warranty that, if you define
2580	SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
2581	buffer is always returned.
2582
2583	The default behavior is just to return the pointer value,
2584	so, be careful.
2585	*/
2586	#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
2587	if (*alloc != SWIG_OLDOBJ)
2588	#else
2589	if (*alloc == SWIG_NEWOBJ)
2590	#endif
2591	{
2592	cptr = (char )memcpy((char )malloc((len + 1)sizeof(char)), cstr, sizeof(char)*(len + 1));
2593	*alloc = SWIG_NEWOBJ;
2594	}
2595	else {
2596	*cptr = cstr;
2597	*alloc = SWIG_OLDOBJ;
2598	}
2599	} else {
2600	*cptr = PyString_AsString(obj);
2601	}
2602	}
2603	if (psize) *psize = len + 1;
2604	return SWIG_OK;
2605	} else {
2606	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2607	if (pchar_descriptor) {
2608	void* vptr = 0;
2609	if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
2610	if (cptr) cptr = (char ) vptr;
2611	if (psize) psize = vptr ? (strlen((char )vptr) + 1) : 0;
2612	if (alloc) *alloc = SWIG_OLDOBJ;
2613	return SWIG_OK;
2614	}
2615	}
2616	}
2617	return SWIG_TypeError;
2618	}
2619
2620
2621
2622
2623
2624	#include <limits.h>
2625	#if !defined(SWIG_NO_LLONG_MAX)
2626	# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2627	# define LLONG_MAX __LONG_LONG_MAX__
2628	# define LLONG_MIN (-LLONG_MAX - 1LL)
2629	# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2630	# endif
2631	#endif
2632
2633
2634	SWIGINTERN int
2635	SWIG_AsVal_double (PyObject obj, double val)
2636	{
2637	int res = SWIG_TypeError;
2638	if (PyFloat_Check(obj)) {
2639	if (val) *val = PyFloat_AsDouble(obj);
2640	return SWIG_OK;
2641	} else if (PyInt_Check(obj)) {
2642	if (val) *val = PyInt_AsLong(obj);
2643	return SWIG_OK;
2644	} else if (PyLong_Check(obj)) {
2645	double v = PyLong_AsDouble(obj);
2646	if (!PyErr_Occurred()) {
2647	if (val) *val = v;
2648	return SWIG_OK;
2649	} else {
2650	PyErr_Clear();
2651	}
2652	}
2653	#ifdef SWIG_PYTHON_CAST_MODE
2654	{
2655	int dispatch = 0;
2656	double d = PyFloat_AsDouble(obj);
2657	if (!PyErr_Occurred()) {
2658	if (val) *val = d;
2659	return SWIG_AddCast(SWIG_OK);
2660	} else {
2661	PyErr_Clear();
2662	}
2663	if (!dispatch) {
2664	long v = PyLong_AsLong(obj);
2665	if (!PyErr_Occurred()) {
2666	if (val) *val = v;
2667	return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2668	} else {
2669	PyErr_Clear();
2670	}
2671	}
2672	}
2673	#endif
2674	return res;
2675	}
2676
2677
2678	#include <float.h>
2679
2680
2681	#include <math.h>
2682
2683
2684	SWIGINTERNINLINE int
2685	SWIG_CanCastAsInteger(double *d, double min, double max) {
2686	double x = *d;
2687	if ((min <= x && x <= max)) {
2688	double fx = floor(x);
2689	double cx = ceil(x);
2690	double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2691	if ((errno == EDOM) \|\| (errno == ERANGE)) {
2692	errno = 0;
2693	} else {
2694	double summ, reps, diff;
2695	if (rd < x) {
2696	diff = x - rd;
2697	} else if (rd > x) {
2698	diff = rd - x;
2699	} else {
2700	return 1;
2701	}
2702	summ = rd + x;
2703	reps = diff/summ;
2704	if (reps < 8*DBL_EPSILON) {
2705	*d = rd;
2706	return 1;
2707	}
2708	}
2709	}
2710	return 0;
2711	}
2712
2713
2714	SWIGINTERN int
2715	SWIG_AsVal_long (PyObject obj, long val)
2716	{
2717	if (PyInt_Check(obj)) {
2718	if (val) *val = PyInt_AsLong(obj);
2719	return SWIG_OK;
2720	} else if (PyLong_Check(obj)) {
2721	long v = PyLong_AsLong(obj);
2722	if (!PyErr_Occurred()) {
2723	if (val) *val = v;
2724	return SWIG_OK;
2725	} else {
2726	PyErr_Clear();
2727	}
2728	}
2729	#ifdef SWIG_PYTHON_CAST_MODE
2730	{
2731	int dispatch = 0;
2732	long v = PyInt_AsLong(obj);
2733	if (!PyErr_Occurred()) {
2734	if (val) *val = v;
2735	return SWIG_AddCast(SWIG_OK);
2736	} else {
2737	PyErr_Clear();
2738	}
2739	if (!dispatch) {
2740	double d;
2741	int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2742	if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2743	if (val) *val = (long)(d);
2744	return res;
2745	}
2746	}
2747	}
2748	#endif
2749	return SWIG_TypeError;
2750	}
2751
2752
2753	SWIGINTERN int
2754	SWIG_AsVal_int (PyObject * obj, int *val)
2755	{
2756	long v;
2757	int res = SWIG_AsVal_long (obj, &v);
2758	if (SWIG_IsOK(res)) {
2759	if ((v < INT_MIN \|\| v > INT_MAX)) {
2760	return SWIG_OverflowError;
2761	} else {
2762	if (val) *val = (int)(v);
2763	}
2764	}
2765	return res;
2766	}
2767
2768	SWIGINTERN tdb new_tdb(char const name,int hash_size,int tdb_flags,int flags,mode_t mode){
2769	return tdb_open(name, hash_size, tdb_flags, flags, mode);
2770	}
2771	SWIGINTERN void delete_tdb(tdb *self){ tdb_close(self); }
2772
2773	SWIGINTERNINLINE PyObject *
2774	SWIG_FromCharPtrAndSize(const char* carray, size_t size)
2775	{
2776	if (carray) {
2777	if (size > INT_MAX) {
2778	swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
2779	return pchar_descriptor ?
2780	SWIG_NewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
2781	} else {
2782	return PyString_FromStringAndSize(carray, (int)(size));
2783	}
2784	} else {
2785	return SWIG_Py_Void();
2786	}
2787	}
2788
2789
2790	SWIGINTERNINLINE PyObject *
2791	SWIG_FromCharPtr(const char *cptr)
2792	{
2793	return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
2794	}
2795
2796
2797	SWIGINTERNINLINE PyObject*
2798	SWIG_From_unsigned_SS_long (unsigned long value)
2799	{
2800	return (value > LONG_MAX) ?
2801	PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
2802	}
2803
2804
2805	SWIGINTERNINLINE PyObject *
2806	SWIG_From_size_t (size_t value)
2807	{
2808	return SWIG_From_unsigned_SS_long ((unsigned long)(value));
2809	}
2810
2811	#ifdef __cplusplus
2812	extern "C" {
2813	#endif
2814	SWIGINTERN PyObject _wrap_new_Tdb(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
2815	PyObject *resultobj = 0;
2816	char arg1 = (char ) 0 ;
2817	int arg2 ;
2818	int arg3 ;
2819	int arg4 ;
2820	mode_t arg5 ;
2821	tdb *result = 0 ;
2822	int res1 ;
2823	char *buf1 = 0 ;
2824	int alloc1 = 0 ;
2825	int val2 ;
2826	int ecode2 = 0 ;
2827	int val3 ;
2828	int ecode3 = 0 ;
2829	int val4 ;
2830	int ecode4 = 0 ;
2831	int val5 ;
2832	int ecode5 = 0 ;
2833	PyObject * obj0 = 0 ;
2834	PyObject * obj1 = 0 ;
2835	PyObject * obj2 = 0 ;
2836	PyObject * obj3 = 0 ;
2837	PyObject * obj4 = 0 ;
2838	char * kwnames[] = {
2839	(char ) "name",(char ) "hash_size",(char ) "tdb_flags",(char ) "flags",(char *) "mode", NULL
2840	};
2841
2842	arg2 = 0;
2843	arg3 = TDB_DEFAULT;
2844	arg4 = O_RDWR;
2845	arg5 = 0600;
2846	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O\|OOOO:new_Tdb",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
2847	res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
2848	if (!SWIG_IsOK(res1)) {
2849	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Tdb" "', argument " "1"" of type '" "char const *""'");
2850	}
2851	arg1 = (char *)(buf1);
2852	if (obj1) {
2853	ecode2 = SWIG_AsVal_int(obj1, &val2);
2854	if (!SWIG_IsOK(ecode2)) {
2855	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Tdb" "', argument " "2"" of type '" "int""'");
2856	}
2857	arg2 = (int)(val2);
2858	}
2859	if (obj2) {
2860	ecode3 = SWIG_AsVal_int(obj2, &val3);
2861	if (!SWIG_IsOK(ecode3)) {
2862	SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Tdb" "', argument " "3"" of type '" "int""'");
2863	}
2864	arg3 = (int)(val3);
2865	}
2866	if (obj3) {
2867	ecode4 = SWIG_AsVal_int(obj3, &val4);
2868	if (!SWIG_IsOK(ecode4)) {
2869	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Tdb" "', argument " "4"" of type '" "int""'");
2870	}
2871	arg4 = (int)(val4);
2872	}
2873	if (obj4) {
2874	ecode5 = SWIG_AsVal_int(obj4, &val5);
2875	if (!SWIG_IsOK(ecode5)) {
2876	SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Tdb" "', argument " "5"" of type '" "mode_t""'");
2877	}
2878	arg5 = (mode_t)(val5);
2879	}
2880	result = (tdb )new_tdb((char const )arg1,arg2,arg3,arg4,arg5);
2881	/* Throw an IOError exception from errno if tdb_open() returns NULL */
2882	if (result == NULL) {
2883	PyErr_SetFromErrno(PyExc_IOError);
2884	SWIG_fail;
2885	}
2886	resultobj = SWIG_NewPointerObj(result, SWIGTYPE_p_tdb_context, 0);
2887	if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2888	return resultobj;
2889	fail:
2890	if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2891	return NULL;
2892	}
2893
2894
2895	SWIGINTERN PyObject _wrap_Tdb_error(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
2896	PyObject *resultobj = 0;
2897	tdb arg1 = (tdb ) 0 ;
2898	enum TDB_ERROR result;
2899	void *argp1 = 0 ;
2900	int res1 = 0 ;
2901	PyObject *swig_obj[1] ;
2902
2903	if (!args) SWIG_fail;
2904	swig_obj[0] = args;
2905	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
2906	if (!SWIG_IsOK(res1)) {
2907	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_error" "', argument " "1"" of type '" "tdb *""'");
2908	}
2909	arg1 = (tdb *)(argp1);
2910	result = (enum TDB_ERROR)tdb_error(arg1);
2911	resultobj = SWIG_From_int((int)(result));
2912	return resultobj;
2913	fail:
2914	return NULL;
2915	}
2916
2917
2918	SWIGINTERN PyObject _wrap_delete_Tdb(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
2919	PyObject *resultobj = 0;
2920	tdb arg1 = (tdb ) 0 ;
2921	void *argp1 = 0 ;
2922	int res1 = 0 ;
2923	PyObject *swig_obj[1] ;
2924
2925	if (!args) SWIG_fail;
2926	swig_obj[0] = args;
2927	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, SWIG_POINTER_DISOWN \| 0 );
2928	if (!SWIG_IsOK(res1)) {
2929	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Tdb" "', argument " "1"" of type '" "tdb *""'");
2930	}
2931	arg1 = (tdb *)(argp1);
2932	delete_tdb(arg1);
2933
2934	resultobj = SWIG_Py_Void();
2935	return resultobj;
2936	fail:
2937	return NULL;
2938	}
2939
2940
2941	SWIGINTERN PyObject _wrap_Tdb_close(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
2942	PyObject *resultobj = 0;
2943	tdb arg1 = (tdb ) 0 ;
2944	int result;
2945	void *argp1 = 0 ;
2946	int res1 = 0 ;
2947	PyObject *swig_obj[1] ;
2948
2949	if (!args) SWIG_fail;
2950	swig_obj[0] = args;
2951	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
2952	if (!SWIG_IsOK(res1)) {
2953	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_close" "', argument " "1"" of type '" "tdb *""'");
2954	}
2955	arg1 = (tdb *)(argp1);
2956	result = (int)tdb_close(arg1);
2957	resultobj = SWIG_From_int((int)(result));
2958	return resultobj;
2959	fail:
2960	return NULL;
2961	}
2962
2963
2964	SWIGINTERN PyObject _wrap_Tdb_append(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
2965	PyObject *resultobj = 0;
2966	tdb arg1 = (tdb ) 0 ;
2967	TDB_DATA arg2 ;
2968	TDB_DATA arg3 ;
2969	int result;
2970	void *argp1 = 0 ;
2971	int res1 = 0 ;
2972	PyObject * obj0 = 0 ;
2973	PyObject * obj1 = 0 ;
2974	PyObject * obj2 = 0 ;
2975	char * kwnames[] = {
2976	(char ) "self",(char ) "key",(char *) "new_dbuf", NULL
2977	};
2978
2979	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Tdb_append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
2980	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
2981	if (!SWIG_IsOK(res1)) {
2982	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_append" "', argument " "1"" of type '" "tdb *""'");
2983	}
2984	arg1 = (tdb *)(argp1);
2985	if (obj1 == Py_None) {
2986	(&arg2)->dsize = 0;
2987	(&arg2)->dptr = NULL;
2988	} else if (!PyString_Check(obj1)) {
2989	PyErr_SetString(PyExc_TypeError, "string arg expected");
2990	return NULL;
2991	} else {
2992	(&arg2)->dsize = PyString_Size(obj1);
2993	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
2994	}
2995	if (obj2 == Py_None) {
2996	(&arg3)->dsize = 0;
2997	(&arg3)->dptr = NULL;
2998	} else if (!PyString_Check(obj2)) {
2999	PyErr_SetString(PyExc_TypeError, "string arg expected");
3000	return NULL;
3001	} else {
3002	(&arg3)->dsize = PyString_Size(obj2);
3003	(&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
3004	}
3005	result = (int)tdb_append(arg1,arg2,arg3);
3006	resultobj = SWIG_From_int((int)(result));
3007	return resultobj;
3008	fail:
3009	return NULL;
3010	}
3011
3012
3013	SWIGINTERN PyObject _wrap_Tdb_errorstr(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3014	PyObject *resultobj = 0;
3015	tdb arg1 = (tdb ) 0 ;
3016	char *result = 0 ;
3017	void *argp1 = 0 ;
3018	int res1 = 0 ;
3019	PyObject *swig_obj[1] ;
3020
3021	if (!args) SWIG_fail;
3022	swig_obj[0] = args;
3023	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3024	if (!SWIG_IsOK(res1)) {
3025	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_errorstr" "', argument " "1"" of type '" "tdb *""'");
3026	}
3027	arg1 = (tdb *)(argp1);
3028	result = (char *)tdb_errorstr(arg1);
3029	resultobj = SWIG_FromCharPtr((const char *)result);
3030	return resultobj;
3031	fail:
3032	return NULL;
3033	}
3034
3035
3036	SWIGINTERN PyObject _wrap_Tdb_get(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3037	PyObject *resultobj = 0;
3038	tdb arg1 = (tdb ) 0 ;
3039	TDB_DATA arg2 ;
3040	TDB_DATA result;
3041	void *argp1 = 0 ;
3042	int res1 = 0 ;
3043	PyObject * obj0 = 0 ;
3044	PyObject * obj1 = 0 ;
3045	char * kwnames[] = {
3046	(char ) "self",(char ) "key", NULL
3047	};
3048
3049	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_get",kwnames,&obj0,&obj1)) SWIG_fail;
3050	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3051	if (!SWIG_IsOK(res1)) {
3052	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_get" "', argument " "1"" of type '" "tdb *""'");
3053	}
3054	arg1 = (tdb *)(argp1);
3055	if (obj1 == Py_None) {
3056	(&arg2)->dsize = 0;
3057	(&arg2)->dptr = NULL;
3058	} else if (!PyString_Check(obj1)) {
3059	PyErr_SetString(PyExc_TypeError, "string arg expected");
3060	return NULL;
3061	} else {
3062	(&arg2)->dsize = PyString_Size(obj1);
3063	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3064	}
3065	result = tdb_fetch(arg1,arg2);
3066	if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3067	resultobj = Py_None;
3068	} else {
3069	resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3070	free((&result)->dptr);
3071	}
3072	return resultobj;
3073	fail:
3074	return NULL;
3075	}
3076
3077
3078	SWIGINTERN PyObject _wrap_Tdb_delete(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3079	PyObject *resultobj = 0;
3080	tdb arg1 = (tdb ) 0 ;
3081	TDB_DATA arg2 ;
3082	int result;
3083	void *argp1 = 0 ;
3084	int res1 = 0 ;
3085	PyObject * obj0 = 0 ;
3086	PyObject * obj1 = 0 ;
3087	char * kwnames[] = {
3088	(char ) "self",(char ) "key", NULL
3089	};
3090
3091	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_delete",kwnames,&obj0,&obj1)) SWIG_fail;
3092	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3093	if (!SWIG_IsOK(res1)) {
3094	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_delete" "', argument " "1"" of type '" "tdb *""'");
3095	}
3096	arg1 = (tdb *)(argp1);
3097	if (obj1 == Py_None) {
3098	(&arg2)->dsize = 0;
3099	(&arg2)->dptr = NULL;
3100	} else if (!PyString_Check(obj1)) {
3101	PyErr_SetString(PyExc_TypeError, "string arg expected");
3102	return NULL;
3103	} else {
3104	(&arg2)->dsize = PyString_Size(obj1);
3105	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3106	}
3107	result = (int)tdb_delete(arg1,arg2);
3108	resultobj = SWIG_From_int((int)(result));
3109	return resultobj;
3110	fail:
3111	return NULL;
3112	}
3113
3114
3115	SWIGINTERN PyObject _wrap_Tdb_store(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3116	PyObject *resultobj = 0;
3117	tdb arg1 = (tdb ) 0 ;
3118	TDB_DATA arg2 ;
3119	TDB_DATA arg3 ;
3120	int arg4 ;
3121	int result;
3122	void *argp1 = 0 ;
3123	int res1 = 0 ;
3124	int val4 ;
3125	int ecode4 = 0 ;
3126	PyObject * obj0 = 0 ;
3127	PyObject * obj1 = 0 ;
3128	PyObject * obj2 = 0 ;
3129	PyObject * obj3 = 0 ;
3130	char * kwnames[] = {
3131	(char ) "self",(char ) "key",(char ) "dbuf",(char ) "flag", NULL
3132	};
3133
3134	arg4 = TDB_REPLACE;
3135	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO\|O:Tdb_store",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3136	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3137	if (!SWIG_IsOK(res1)) {
3138	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_store" "', argument " "1"" of type '" "tdb *""'");
3139	}
3140	arg1 = (tdb *)(argp1);
3141	if (obj1 == Py_None) {
3142	(&arg2)->dsize = 0;
3143	(&arg2)->dptr = NULL;
3144	} else if (!PyString_Check(obj1)) {
3145	PyErr_SetString(PyExc_TypeError, "string arg expected");
3146	return NULL;
3147	} else {
3148	(&arg2)->dsize = PyString_Size(obj1);
3149	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3150	}
3151	if (obj2 == Py_None) {
3152	(&arg3)->dsize = 0;
3153	(&arg3)->dptr = NULL;
3154	} else if (!PyString_Check(obj2)) {
3155	PyErr_SetString(PyExc_TypeError, "string arg expected");
3156	return NULL;
3157	} else {
3158	(&arg3)->dsize = PyString_Size(obj2);
3159	(&arg3)->dptr = (uint8_t *)PyString_AsString(obj2);
3160	}
3161	if (obj3) {
3162	ecode4 = SWIG_AsVal_int(obj3, &val4);
3163	if (!SWIG_IsOK(ecode4)) {
3164	SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Tdb_store" "', argument " "4"" of type '" "int""'");
3165	}
3166	arg4 = (int)(val4);
3167	}
3168	result = (int)tdb_store(arg1,arg2,arg3,arg4);
3169	resultobj = SWIG_From_int((int)(result));
3170	return resultobj;
3171	fail:
3172	return NULL;
3173	}
3174
3175
3176	SWIGINTERN PyObject _wrap_Tdb_exists(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3177	PyObject *resultobj = 0;
3178	tdb arg1 = (tdb ) 0 ;
3179	TDB_DATA arg2 ;
3180	int result;
3181	void *argp1 = 0 ;
3182	int res1 = 0 ;
3183	PyObject * obj0 = 0 ;
3184	PyObject * obj1 = 0 ;
3185	char * kwnames[] = {
3186	(char ) "self",(char ) "key", NULL
3187	};
3188
3189	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_exists",kwnames,&obj0,&obj1)) SWIG_fail;
3190	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3191	if (!SWIG_IsOK(res1)) {
3192	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_exists" "', argument " "1"" of type '" "tdb *""'");
3193	}
3194	arg1 = (tdb *)(argp1);
3195	if (obj1 == Py_None) {
3196	(&arg2)->dsize = 0;
3197	(&arg2)->dptr = NULL;
3198	} else if (!PyString_Check(obj1)) {
3199	PyErr_SetString(PyExc_TypeError, "string arg expected");
3200	return NULL;
3201	} else {
3202	(&arg2)->dsize = PyString_Size(obj1);
3203	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3204	}
3205	result = (int)tdb_exists(arg1,arg2);
3206	resultobj = SWIG_From_int((int)(result));
3207	return resultobj;
3208	fail:
3209	return NULL;
3210	}
3211
3212
3213	SWIGINTERN PyObject _wrap_Tdb_firstkey(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3214	PyObject *resultobj = 0;
3215	tdb arg1 = (tdb ) 0 ;
3216	TDB_DATA result;
3217	void *argp1 = 0 ;
3218	int res1 = 0 ;
3219	PyObject *swig_obj[1] ;
3220
3221	if (!args) SWIG_fail;
3222	swig_obj[0] = args;
3223	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3224	if (!SWIG_IsOK(res1)) {
3225	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_firstkey" "', argument " "1"" of type '" "tdb *""'");
3226	}
3227	arg1 = (tdb *)(argp1);
3228	result = tdb_firstkey(arg1);
3229	if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3230	resultobj = Py_None;
3231	} else {
3232	resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3233	free((&result)->dptr);
3234	}
3235	return resultobj;
3236	fail:
3237	return NULL;
3238	}
3239
3240
3241	SWIGINTERN PyObject _wrap_Tdb_nextkey(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3242	PyObject *resultobj = 0;
3243	tdb arg1 = (tdb ) 0 ;
3244	TDB_DATA arg2 ;
3245	TDB_DATA result;
3246	void *argp1 = 0 ;
3247	int res1 = 0 ;
3248	PyObject * obj0 = 0 ;
3249	PyObject * obj1 = 0 ;
3250	char * kwnames[] = {
3251	(char ) "self",(char ) "key", NULL
3252	};
3253
3254	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_nextkey",kwnames,&obj0,&obj1)) SWIG_fail;
3255	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3256	if (!SWIG_IsOK(res1)) {
3257	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_nextkey" "', argument " "1"" of type '" "tdb *""'");
3258	}
3259	arg1 = (tdb *)(argp1);
3260	if (obj1 == Py_None) {
3261	(&arg2)->dsize = 0;
3262	(&arg2)->dptr = NULL;
3263	} else if (!PyString_Check(obj1)) {
3264	PyErr_SetString(PyExc_TypeError, "string arg expected");
3265	return NULL;
3266	} else {
3267	(&arg2)->dsize = PyString_Size(obj1);
3268	(&arg2)->dptr = (uint8_t *)PyString_AsString(obj1);
3269	}
3270	result = tdb_nextkey(arg1,arg2);
3271	if ((&result)->dptr == NULL && (&result)->dsize == 0) {
3272	resultobj = Py_None;
3273	} else {
3274	resultobj = PyString_FromStringAndSize((const char *)(&result)->dptr, (&result)->dsize);
3275	free((&result)->dptr);
3276	}
3277	return resultobj;
3278	fail:
3279	return NULL;
3280	}
3281
3282
3283	SWIGINTERN PyObject _wrap_Tdb_lock_all(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3284	PyObject *resultobj = 0;
3285	tdb arg1 = (tdb ) 0 ;
3286	int result;
3287	void *argp1 = 0 ;
3288	int res1 = 0 ;
3289	PyObject *swig_obj[1] ;
3290
3291	if (!args) SWIG_fail;
3292	swig_obj[0] = args;
3293	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3294	if (!SWIG_IsOK(res1)) {
3295	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_lock_all" "', argument " "1"" of type '" "tdb *""'");
3296	}
3297	arg1 = (tdb *)(argp1);
3298	result = (int)tdb_lockall(arg1);
3299	resultobj = SWIG_From_int((int)(result));
3300	return resultobj;
3301	fail:
3302	return NULL;
3303	}
3304
3305
3306	SWIGINTERN PyObject _wrap_Tdb_unlock_all(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3307	PyObject *resultobj = 0;
3308	tdb arg1 = (tdb ) 0 ;
3309	int result;
3310	void *argp1 = 0 ;
3311	int res1 = 0 ;
3312	PyObject *swig_obj[1] ;
3313
3314	if (!args) SWIG_fail;
3315	swig_obj[0] = args;
3316	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3317	if (!SWIG_IsOK(res1)) {
3318	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_unlock_all" "', argument " "1"" of type '" "tdb *""'");
3319	}
3320	arg1 = (tdb *)(argp1);
3321	result = (int)tdb_unlockall(arg1);
3322	resultobj = SWIG_From_int((int)(result));
3323	return resultobj;
3324	fail:
3325	return NULL;
3326	}
3327
3328
3329	SWIGINTERN PyObject _wrap_Tdb_read_lock_all(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3330	PyObject *resultobj = 0;
3331	tdb arg1 = (tdb ) 0 ;
3332	int result;
3333	void *argp1 = 0 ;
3334	int res1 = 0 ;
3335	PyObject *swig_obj[1] ;
3336
3337	if (!args) SWIG_fail;
3338	swig_obj[0] = args;
3339	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3340	if (!SWIG_IsOK(res1)) {
3341	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_read_lock_all" "', argument " "1"" of type '" "tdb *""'");
3342	}
3343	arg1 = (tdb *)(argp1);
3344	result = (int)tdb_lockall_read(arg1);
3345	resultobj = SWIG_From_int((int)(result));
3346	return resultobj;
3347	fail:
3348	return NULL;
3349	}
3350
3351
3352	SWIGINTERN PyObject _wrap_Tdb_read_unlock_all(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3353	PyObject *resultobj = 0;
3354	tdb arg1 = (tdb ) 0 ;
3355	int result;
3356	void *argp1 = 0 ;
3357	int res1 = 0 ;
3358	PyObject *swig_obj[1] ;
3359
3360	if (!args) SWIG_fail;
3361	swig_obj[0] = args;
3362	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3363	if (!SWIG_IsOK(res1)) {
3364	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_read_unlock_all" "', argument " "1"" of type '" "tdb *""'");
3365	}
3366	arg1 = (tdb *)(argp1);
3367	result = (int)tdb_unlockall_read(arg1);
3368	resultobj = SWIG_From_int((int)(result));
3369	return resultobj;
3370	fail:
3371	return NULL;
3372	}
3373
3374
3375	SWIGINTERN PyObject _wrap_Tdb_reopen(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3376	PyObject *resultobj = 0;
3377	tdb arg1 = (tdb ) 0 ;
3378	int result;
3379	void *argp1 = 0 ;
3380	int res1 = 0 ;
3381	PyObject *swig_obj[1] ;
3382
3383	if (!args) SWIG_fail;
3384	swig_obj[0] = args;
3385	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3386	if (!SWIG_IsOK(res1)) {
3387	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_reopen" "', argument " "1"" of type '" "tdb *""'");
3388	}
3389	arg1 = (tdb *)(argp1);
3390	result = (int)tdb_reopen(arg1);
3391	resultobj = SWIG_From_int((int)(result));
3392	return resultobj;
3393	fail:
3394	return NULL;
3395	}
3396
3397
3398	SWIGINTERN PyObject _wrap_Tdb_transaction_start(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3399	PyObject *resultobj = 0;
3400	tdb arg1 = (tdb ) 0 ;
3401	int result;
3402	void *argp1 = 0 ;
3403	int res1 = 0 ;
3404	PyObject *swig_obj[1] ;
3405
3406	if (!args) SWIG_fail;
3407	swig_obj[0] = args;
3408	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3409	if (!SWIG_IsOK(res1)) {
3410	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_start" "', argument " "1"" of type '" "tdb *""'");
3411	}
3412	arg1 = (tdb *)(argp1);
3413	result = (int)tdb_transaction_start(arg1);
3414	resultobj = SWIG_From_int((int)(result));
3415	return resultobj;
3416	fail:
3417	return NULL;
3418	}
3419
3420
3421	SWIGINTERN PyObject _wrap_Tdb_transaction_commit(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3422	PyObject *resultobj = 0;
3423	tdb arg1 = (tdb ) 0 ;
3424	int result;
3425	void *argp1 = 0 ;
3426	int res1 = 0 ;
3427	PyObject *swig_obj[1] ;
3428
3429	if (!args) SWIG_fail;
3430	swig_obj[0] = args;
3431	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3432	if (!SWIG_IsOK(res1)) {
3433	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_commit" "', argument " "1"" of type '" "tdb *""'");
3434	}
3435	arg1 = (tdb *)(argp1);
3436	result = (int)tdb_transaction_commit(arg1);
3437	resultobj = SWIG_From_int((int)(result));
3438	return resultobj;
3439	fail:
3440	return NULL;
3441	}
3442
3443
3444	SWIGINTERN PyObject _wrap_Tdb_transaction_cancel(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3445	PyObject *resultobj = 0;
3446	tdb arg1 = (tdb ) 0 ;
3447	int result;
3448	void *argp1 = 0 ;
3449	int res1 = 0 ;
3450	PyObject *swig_obj[1] ;
3451
3452	if (!args) SWIG_fail;
3453	swig_obj[0] = args;
3454	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3455	if (!SWIG_IsOK(res1)) {
3456	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_cancel" "', argument " "1"" of type '" "tdb *""'");
3457	}
3458	arg1 = (tdb *)(argp1);
3459	result = (int)tdb_transaction_cancel(arg1);
3460	resultobj = SWIG_From_int((int)(result));
3461	return resultobj;
3462	fail:
3463	return NULL;
3464	}
3465
3466
3467	SWIGINTERN PyObject _wrap_Tdb_transaction_recover(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3468	PyObject *resultobj = 0;
3469	tdb arg1 = (tdb ) 0 ;
3470	int result;
3471	void *argp1 = 0 ;
3472	int res1 = 0 ;
3473	PyObject *swig_obj[1] ;
3474
3475	if (!args) SWIG_fail;
3476	swig_obj[0] = args;
3477	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3478	if (!SWIG_IsOK(res1)) {
3479	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_transaction_recover" "', argument " "1"" of type '" "tdb *""'");
3480	}
3481	arg1 = (tdb *)(argp1);
3482	result = (int)tdb_transaction_recover(arg1);
3483	resultobj = SWIG_From_int((int)(result));
3484	return resultobj;
3485	fail:
3486	return NULL;
3487	}
3488
3489
3490	SWIGINTERN PyObject _wrap_Tdb_hash_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3491	PyObject *resultobj = 0;
3492	tdb arg1 = (tdb ) 0 ;
3493	int result;
3494	void *argp1 = 0 ;
3495	int res1 = 0 ;
3496	PyObject *swig_obj[1] ;
3497
3498	if (!args) SWIG_fail;
3499	swig_obj[0] = args;
3500	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3501	if (!SWIG_IsOK(res1)) {
3502	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_hash_size" "', argument " "1"" of type '" "tdb *""'");
3503	}
3504	arg1 = (tdb *)(argp1);
3505	result = (int)tdb_hash_size(arg1);
3506	resultobj = SWIG_From_int((int)(result));
3507	return resultobj;
3508	fail:
3509	return NULL;
3510	}
3511
3512
3513	SWIGINTERN PyObject _wrap_Tdb_map_size(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3514	PyObject *resultobj = 0;
3515	tdb arg1 = (tdb ) 0 ;
3516	size_t result;
3517	void *argp1 = 0 ;
3518	int res1 = 0 ;
3519	PyObject *swig_obj[1] ;
3520
3521	if (!args) SWIG_fail;
3522	swig_obj[0] = args;
3523	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3524	if (!SWIG_IsOK(res1)) {
3525	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_map_size" "', argument " "1"" of type '" "tdb *""'");
3526	}
3527	arg1 = (tdb *)(argp1);
3528	result = tdb_map_size(arg1);
3529	resultobj = SWIG_From_size_t((size_t)(result));
3530	return resultobj;
3531	fail:
3532	return NULL;
3533	}
3534
3535
3536	SWIGINTERN PyObject _wrap_Tdb_get_flags(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3537	PyObject *resultobj = 0;
3538	tdb arg1 = (tdb ) 0 ;
3539	int result;
3540	void *argp1 = 0 ;
3541	int res1 = 0 ;
3542	PyObject *swig_obj[1] ;
3543
3544	if (!args) SWIG_fail;
3545	swig_obj[0] = args;
3546	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3547	if (!SWIG_IsOK(res1)) {
3548	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_get_flags" "', argument " "1"" of type '" "tdb *""'");
3549	}
3550	arg1 = (tdb *)(argp1);
3551	result = (int)tdb_get_flags(arg1);
3552	resultobj = SWIG_From_int((int)(result));
3553	return resultobj;
3554	fail:
3555	return NULL;
3556	}
3557
3558
3559	SWIGINTERN PyObject _wrap_Tdb_set_max_dead(PyObject SWIGUNUSEDPARM(self), PyObject args, PyObject kwargs) {
3560	PyObject *resultobj = 0;
3561	tdb arg1 = (tdb ) 0 ;
3562	int arg2 ;
3563	void *argp1 = 0 ;
3564	int res1 = 0 ;
3565	int val2 ;
3566	int ecode2 = 0 ;
3567	PyObject * obj0 = 0 ;
3568	PyObject * obj1 = 0 ;
3569	char * kwnames[] = {
3570	(char ) "self",(char ) "max_dead", NULL
3571	};
3572
3573	if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Tdb_set_max_dead",kwnames,&obj0,&obj1)) SWIG_fail;
3574	res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3575	if (!SWIG_IsOK(res1)) {
3576	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_set_max_dead" "', argument " "1"" of type '" "tdb *""'");
3577	}
3578	arg1 = (tdb *)(argp1);
3579	ecode2 = SWIG_AsVal_int(obj1, &val2);
3580	if (!SWIG_IsOK(ecode2)) {
3581	SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Tdb_set_max_dead" "', argument " "2"" of type '" "int""'");
3582	}
3583	arg2 = (int)(val2);
3584	tdb_set_max_dead(arg1,arg2);
3585	resultobj = SWIG_Py_Void();
3586	return resultobj;
3587	fail:
3588	return NULL;
3589	}
3590
3591
3592	SWIGINTERN PyObject _wrap_Tdb_name(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3593	PyObject *resultobj = 0;
3594	tdb arg1 = (tdb ) 0 ;
3595	char *result = 0 ;
3596	void *argp1 = 0 ;
3597	int res1 = 0 ;
3598	PyObject *swig_obj[1] ;
3599
3600	if (!args) SWIG_fail;
3601	swig_obj[0] = args;
3602	res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_tdb_context, 0 \| 0 );
3603	if (!SWIG_IsOK(res1)) {
3604	SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Tdb_name" "', argument " "1"" of type '" "tdb *""'");
3605	}
3606	arg1 = (tdb *)(argp1);
3607	result = (char *)tdb_name(arg1);
3608	resultobj = SWIG_FromCharPtr((const char *)result);
3609	return resultobj;
3610	fail:
3611	return NULL;
3612	}
3613
3614
3615	SWIGINTERN PyObject Tdb_swigregister(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3616	PyObject *obj;
3617	if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
3618	SWIG_TypeNewClientData(SWIGTYPE_p_tdb_context, SWIG_NewClientData(obj));
3619	return SWIG_Py_Void();
3620	}
3621
3622	SWIGINTERN PyObject Tdb_swiginit(PyObject SWIGUNUSEDPARM(self), PyObject *args) {
3623	return SWIG_Python_InitShadowInstance(args);
3624	}
3625
3626	static PyMethodDef SwigMethods[] = {
3627	{ (char )"new_Tdb", (PyCFunction) _wrap_new_Tdb, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3628	"S.__init__(name,hash_size=0,tdb_flags=TDB_DEFAULT,flags=O_RDWR,mode=0600)\n"
3629	"Open a TDB file.\n"
3630	""},
3631	{ (char )"Tdb_error", (PyCFunction)_wrap_Tdb_error, METH_O, (char )"\n"
3632	"S.error() -> int\n"
3633	"Find last error number returned by operation on this TDB.\n"
3634	""},
3635	{ (char *)"delete_Tdb", (PyCFunction)_wrap_delete_Tdb, METH_O, NULL},
3636	{ (char )"Tdb_close", (PyCFunction)_wrap_Tdb_close, METH_O, (char )"\n"
3637	"S.close() -> None\n"
3638	"Close the TDB file.\n"
3639	""},
3640	{ (char *)"Tdb_append", (PyCFunction) _wrap_Tdb_append, METH_VARARGS \| METH_KEYWORDS, NULL},
3641	{ (char )"Tdb_errorstr", (PyCFunction)_wrap_Tdb_errorstr, METH_O, (char )"\n"
3642	"S.errorstr() -> errorstring\n"
3643	"Obtain last error message.\n"
3644	""},
3645	{ (char )"Tdb_get", (PyCFunction) _wrap_Tdb_get, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3646	"S.fetch(key) -> value\n"
3647	"Fetch a value.\n"
3648	""},
3649	{ (char )"Tdb_delete", (PyCFunction) _wrap_Tdb_delete, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3650	"S.delete(key) -> None\n"
3651	"Delete an entry.\n"
3652	""},
3653	{ (char )"Tdb_store", (PyCFunction) _wrap_Tdb_store, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3654	"S.store(key, value, flag=TDB_REPLACE) -> None\n"
3655	"Store an entry.\n"
3656	""},
3657	{ (char )"Tdb_exists", (PyCFunction) _wrap_Tdb_exists, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3658	"S.exists(key) -> bool\n"
3659	"Check whether key exists in this database.\n"
3660	""},
3661	{ (char )"Tdb_firstkey", (PyCFunction)_wrap_Tdb_firstkey, METH_O, (char )"\n"
3662	"S.firstkey() -> data\n"
3663	"Return the first key in this database.\n"
3664	""},
3665	{ (char )"Tdb_nextkey", (PyCFunction) _wrap_Tdb_nextkey, METH_VARARGS \| METH_KEYWORDS, (char )"\n"
3666	"S.nextkey(prev) -> data\n"
3667	"Return the next key in this database.\n"
3668	""},
3669	{ (char )"Tdb_lock_all", (PyCFunction)_wrap_Tdb_lock_all, METH_O, (char )"S.lockall() -> bool"},
3670	{ (char )"Tdb_unlock_all", (PyCFunction)_wrap_Tdb_unlock_all, METH_O, (char )"S.unlockall() -> bool"},
3671	{ (char *)"Tdb_read_lock_all", (PyCFunction)_wrap_Tdb_read_lock_all, METH_O, NULL},
3672	{ (char *)"Tdb_read_unlock_all", (PyCFunction)_wrap_Tdb_read_unlock_all, METH_O, NULL},
3673	{ (char )"Tdb_reopen", (PyCFunction)_wrap_Tdb_reopen, METH_O, (char )"\n"
3674	"S.reopen() -> bool\n"
3675	"Reopen this file.\n"
3676	""},
3677	{ (char )"Tdb_transaction_start", (PyCFunction)_wrap_Tdb_transaction_start, METH_O, (char )"\n"
3678	"S.transaction_start() -> None\n"
3679	"Start a new transaction.\n"
3680	""},
3681	{ (char )"Tdb_transaction_commit", (PyCFunction)_wrap_Tdb_transaction_commit, METH_O, (char )"\n"
3682	"S.transaction_commit() -> None\n"
3683	"Commit the currently active transaction.\n"
3684	""},
3685	{ (char )"Tdb_transaction_cancel", (PyCFunction)_wrap_Tdb_transaction_cancel, METH_O, (char )"\n"
3686	"S.transaction_cancel() -> None\n"
3687	"Cancel the currently active transaction.\n"
3688	""},
3689	{ (char *)"Tdb_transaction_recover", (PyCFunction)_wrap_Tdb_transaction_recover, METH_O, NULL},
3690	{ (char )"Tdb_hash_size", (PyCFunction)_wrap_Tdb_hash_size, METH_O, (char )"S.hash_size() -> int"},
3691	{ (char )"Tdb_map_size", (PyCFunction)_wrap_Tdb_map_size, METH_O, (char )"S.map_size() -> int"},
3692	{ (char )"Tdb_get_flags", (PyCFunction)_wrap_Tdb_get_flags, METH_O, (char )"S.get_flags() -> int"},
3693	{ (char )"Tdb_set_max_dead", (PyCFunction) _wrap_Tdb_set_max_dead, METH_VARARGS \| METH_KEYWORDS, (char )"S.set_max_dead(int) -> None"},
3694	{ (char )"Tdb_name", (PyCFunction)_wrap_Tdb_name, METH_O, (char )"\n"
3695	"S.name() -> path\n"
3696	"Return filename of this TDB file.\n"
3697	""},
3698	{ (char *)"Tdb_swigregister", Tdb_swigregister, METH_VARARGS, NULL},
3699	{ (char *)"Tdb_swiginit", Tdb_swiginit, METH_VARARGS, NULL},
3700	{ NULL, NULL, 0, NULL }
3701	};
3702
3703
3704	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3705
3706	static swig_type_info _swigt__p_TDB_DATA = {"_p_TDB_DATA", "TDB_DATA ", 0, 0, (void)0, 0};
3707	static swig_type_info _swigt__p_char = {"_p_char", "char ", 0, 0, (void)0, 0};
3708	static swig_type_info _swigt__p_int = {"_p_int", "intptr_t \|int \|int_least32_t \|int_fast32_t \|int32_t \|int_fast16_t \|mode_t ", 0, 0, (void)0, 0};
3709	static swig_type_info _swigt__p_long_long = {"_p_long_long", "int_least64_t \|int_fast64_t \|int64_t \|long long \|intmax_t ", 0, 0, (void)0, 0};
3710	static swig_type_info _swigt__p_short = {"_p_short", "short \|int_least16_t \|int16_t ", 0, 0, (void)0, 0};
3711	static swig_type_info _swigt__p_signed_char = {"_p_signed_char", "signed char \|int_least8_t \|int_fast8_t \|int8_t ", 0, 0, (void*)0, 0};
3712	static swig_type_info _swigt__p_tdb_context = {"_p_tdb_context", "struct tdb_context \|tdb ", 0, 0, (void*)0, 0};
3713	static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char \|uint_least8_t \|uint_fast8_t \|uint8_t ", 0, 0, (void*)0, 0};
3714	static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uintptr_t \|uint_least32_t \|uint_fast32_t \|uint32_t \|unsigned int \|uint_fast16_t ", 0, 0, (void*)0, 0};
3715	static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint_least64_t \|uint_fast64_t \|uint64_t \|unsigned long long \|uintmax_t ", 0, 0, (void)0, 0};
3716	static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short \|uint_least16_t \|uint16_t ", 0, 0, (void)0, 0};
3717
3718	static swig_type_info *swig_type_initial[] = {
3719	&_swigt__p_TDB_DATA,
3720	&_swigt__p_char,
3721	&_swigt__p_int,
3722	&_swigt__p_long_long,
3723	&_swigt__p_short,
3724	&_swigt__p_signed_char,
3725	&_swigt__p_tdb_context,
3726	&_swigt__p_unsigned_char,
3727	&_swigt__p_unsigned_int,
3728	&_swigt__p_unsigned_long_long,
3729	&_swigt__p_unsigned_short,
3730	};
3731
3732	static swig_cast_info _swigc__p_TDB_DATA[] = { {&_swigt__p_TDB_DATA, 0, 0, 0},{0, 0, 0, 0}};
3733	static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3734	static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
3735	static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
3736	static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
3737	static swig_cast_info _swigc__p_signed_char[] = { {&_swigt__p_signed_char, 0, 0, 0},{0, 0, 0, 0}};
3738	static swig_cast_info _swigc__p_tdb_context[] = { {&_swigt__p_tdb_context, 0, 0, 0},{0, 0, 0, 0}};
3739	static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
3740	static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
3741	static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}};
3742	static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
3743
3744	static swig_cast_info *swig_cast_initial[] = {
3745	_swigc__p_TDB_DATA,
3746	_swigc__p_char,
3747	_swigc__p_int,
3748	_swigc__p_long_long,
3749	_swigc__p_short,
3750	_swigc__p_signed_char,
3751	_swigc__p_tdb_context,
3752	_swigc__p_unsigned_char,
3753	_swigc__p_unsigned_int,
3754	_swigc__p_unsigned_long_long,
3755	_swigc__p_unsigned_short,
3756	};
3757
3758
3759	/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3760
3761	static swig_const_info swig_const_table[] = {
3762	{0, 0, 0, 0.0, 0, 0}};
3763
3764	#ifdef __cplusplus
3765	}
3766	#endif
3767	/* -----------------------------------------------------------------------------
3768	* Type initialization:
3769	* This problem is tough by the requirement that no dynamic
3770	* memory is used. Also, since swig_type_info structures store pointers to
3771	* swig_cast_info structures and swig_cast_info structures store pointers back
3772	* to swig_type_info structures, we need some lookup code at initialization.
3773	* The idea is that swig generates all the structures that are needed.
3774	* The runtime then collects these partially filled structures.
3775	* The SWIG_InitializeModule function takes these initial arrays out of
3776	* swig_module, and does all the lookup, filling in the swig_module.types
3777	* array with the correct data and linking the correct swig_cast_info
3778	* structures together.
3779	*
3780	* The generated swig_type_info structures are assigned staticly to an initial
3781	* array. We just loop through that array, and handle each type individually.
3782	* First we lookup if this type has been already loaded, and if so, use the
3783	* loaded structure instead of the generated one. Then we have to fill in the
3784	* cast linked list. The cast data is initially stored in something like a
3785	* two-dimensional array. Each row corresponds to a type (there are the same
3786	* number of rows as there are in the swig_type_initial array). Each entry in
3787	* a column is one of the swig_cast_info structures for that type.
3788	* The cast_initial array is actually an array of arrays, because each row has
3789	* a variable number of columns. So to actually build the cast linked list,
3790	* we find the array of casts associated with the type, and loop through it
3791	* adding the casts to the list. The one last trick we need to do is making
3792	* sure the type pointer in the swig_cast_info struct is correct.
3793	*
3794	* First off, we lookup the cast->type name to see if it is already loaded.
3795	* There are three cases to handle:
3796	* 1) If the cast->type has already been loaded AND the type we are adding
3797	* casting info to has not been loaded (it is in this module), THEN we
3798	* replace the cast->type pointer with the type pointer that has already
3799	* been loaded.
3800	* 2) If BOTH types (the one we are adding casting info to, and the
3801	* cast->type) are loaded, THEN the cast info has already been loaded by
3802	* the previous module so we just ignore it.
3803	* 3) Finally, if cast->type has not already been loaded, then we add that
3804	* swig_cast_info to the linked list (because the cast->type) pointer will
3805	* be correct.
3806	* ----------------------------------------------------------------------------- */
3807
3808	#ifdef __cplusplus
3809	extern "C" {
3810	#if 0
3811	} /* c-mode */
3812	#endif
3813	#endif
3814
3815	#if 0
3816	#define SWIGRUNTIME_DEBUG
3817	#endif
3818
3819
3820	SWIGRUNTIME void
3821	SWIG_InitializeModule(void *clientdata) {
3822	size_t i;
3823	swig_module_info module_head, iter;
3824	int found, init;
3825
3826	clientdata = clientdata;
3827
3828	/* check to see if the circular list has been setup, if not, set it up */
3829	if (swig_module.next==0) {
3830	/* Initialize the swig_module */
3831	swig_module.type_initial = swig_type_initial;
3832	swig_module.cast_initial = swig_cast_initial;
3833	swig_module.next = &swig_module;
3834	init = 1;
3835	} else {
3836	init = 0;
3837	}
3838
3839	/* Try and load any already created modules */
3840	module_head = SWIG_GetModule(clientdata);
3841	if (!module_head) {
3842	/* This is the first module loaded for this interpreter */
3843	/* so set the swig module into the interpreter */
3844	SWIG_SetModule(clientdata, &swig_module);
3845	module_head = &swig_module;
3846	} else {
3847	/* the interpreter has loaded a SWIG module, but has it loaded this one? */
3848	found=0;
3849	iter=module_head;
3850	do {
3851	if (iter==&swig_module) {
3852	found=1;
3853	break;
3854	}
3855	iter=iter->next;
3856	} while (iter!= module_head);
3857
3858	/* if the is found in the list, then all is done and we may leave */
3859	if (found) return;
3860	/* otherwise we must add out module into the list */
3861	swig_module.next = module_head->next;
3862	module_head->next = &swig_module;
3863	}
3864
3865	/* When multiple interpeters are used, a module could have already been initialized in
3866	a different interpreter, but not yet have a pointer in this interpreter.
3867	In this case, we do not want to continue adding types... everything should be
3868	set up already */
3869	if (init == 0) return;
3870
3871	/* Now work on filling in swig_module.types */
3872	#ifdef SWIGRUNTIME_DEBUG
3873	printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3874	#endif
3875	for (i = 0; i < swig_module.size; ++i) {
3876	swig_type_info *type = 0;
3877	swig_type_info *ret;
3878	swig_cast_info *cast;
3879
3880	#ifdef SWIGRUNTIME_DEBUG
3881	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3882	#endif
3883
3884	/* if there is another module already loaded */
3885	if (swig_module.next != &swig_module) {
3886	type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3887	}
3888	if (type) {
3889	/* Overwrite clientdata field */
3890	#ifdef SWIGRUNTIME_DEBUG
3891	printf("SWIG_InitializeModule: found type %s\n", type->name);
3892	#endif
3893	if (swig_module.type_initial[i]->clientdata) {
3894	type->clientdata = swig_module.type_initial[i]->clientdata;
3895	#ifdef SWIGRUNTIME_DEBUG
3896	printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3897	#endif
3898	}
3899	} else {
3900	type = swig_module.type_initial[i];
3901	}
3902
3903	/* Insert casting types */
3904	cast = swig_module.cast_initial[i];
3905	while (cast->type) {
3906	/* Don't need to add information already in the list */
3907	ret = 0;
3908	#ifdef SWIGRUNTIME_DEBUG
3909	printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3910	#endif
3911	if (swig_module.next != &swig_module) {
3912	ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3913	#ifdef SWIGRUNTIME_DEBUG
3914	if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3915	#endif
3916	}
3917	if (ret) {
3918	if (type == swig_module.type_initial[i]) {
3919	#ifdef SWIGRUNTIME_DEBUG
3920	printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3921	#endif
3922	cast->type = ret;
3923	ret = 0;
3924	} else {
3925	/* Check for casting already in the list */
3926	swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3927	#ifdef SWIGRUNTIME_DEBUG
3928	if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3929	#endif
3930	if (!ocast) ret = 0;
3931	}
3932	}
3933
3934	if (!ret) {
3935	#ifdef SWIGRUNTIME_DEBUG
3936	printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3937	#endif
3938	if (type->cast) {
3939	type->cast->prev = cast;
3940	cast->next = type->cast;
3941	}
3942	type->cast = cast;
3943	}
3944	cast++;
3945	}
3946	/* Set entry in modules->types array equal to the type */
3947	swig_module.types[i] = type;
3948	}
3949	swig_module.types[i] = 0;
3950
3951	#ifdef SWIGRUNTIME_DEBUG
3952	printf("** SWIG_InitializeModule: Cast List ****\n");
3953	for (i = 0; i < swig_module.size; ++i) {
3954	int j = 0;
3955	swig_cast_info *cast = swig_module.cast_initial[i];
3956	printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3957	while (cast->type) {
3958	printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3959	cast++;
3960	++j;
3961	}
3962	printf("---- Total casts: %d\n",j);
3963	}
3964	printf("** SWIG_InitializeModule: Cast List ****\n");
3965	#endif
3966	}
3967
3968	/* This function will propagate the clientdata field of type to
3969	* any new swig_type_info structures that have been added into the list
3970	* of equivalent types. It is like calling
3971	* SWIG_TypeClientData(type, clientdata) a second time.
3972	*/
3973	SWIGRUNTIME void
3974	SWIG_PropagateClientData(void) {
3975	size_t i;
3976	swig_cast_info *equiv;
3977	static int init_run = 0;
3978
3979	if (init_run) return;
3980	init_run = 1;
3981
3982	for (i = 0; i < swig_module.size; i++) {
3983	if (swig_module.types[i]->clientdata) {
3984	equiv = swig_module.types[i]->cast;
3985	while (equiv) {
3986	if (!equiv->converter) {
3987	if (equiv->type && !equiv->type->clientdata)
3988	SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3989	}
3990	equiv = equiv->next;
3991	}
3992	}
3993	}
3994	}
3995
3996	#ifdef __cplusplus
3997	#if 0
3998	{
3999	/* c-mode */
4000	#endif
4001	}
4002	#endif
4003
4004
4005
4006	#ifdef __cplusplus
4007	extern "C" {
4008	#endif
4009
4010	/* Python-specific SWIG API */
4011	#define SWIG_newvarlink() SWIG_Python_newvarlink()
4012	#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
4013	#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
4014
4015	/* -----------------------------------------------------------------------------
4016	* global variable support code.
4017	* ----------------------------------------------------------------------------- */
4018
4019	typedef struct swig_globalvar {
4020	char name; / Name of global variable */
4021	PyObject (get_attr)(void); /* Return the current value */
4022	int (set_attr)(PyObject ); /* Set the value */
4023	struct swig_globalvar *next;
4024	} swig_globalvar;
4025
4026	typedef struct swig_varlinkobject {
4027	PyObject_HEAD
4028	swig_globalvar *vars;
4029	} swig_varlinkobject;
4030
4031	SWIGINTERN PyObject *
4032	swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
4033	return PyString_FromString("<Swig global variables>");
4034	}
4035
4036	SWIGINTERN PyObject *
4037	swig_varlink_str(swig_varlinkobject *v) {
4038	PyObject *str = PyString_FromString("(");
4039	swig_globalvar *var;
4040	for (var = v->vars; var; var=var->next) {
4041	PyString_ConcatAndDel(&str,PyString_FromString(var->name));
4042	if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
4043	}
4044	PyString_ConcatAndDel(&str,PyString_FromString(")"));
4045	return str;
4046	}
4047
4048	SWIGINTERN int
4049	swig_varlink_print(swig_varlinkobject v, FILE fp, int SWIGUNUSEDPARM(flags)) {
4050	PyObject *str = swig_varlink_str(v);
4051	fprintf(fp,"Swig global variables ");
4052	fprintf(fp,"%s\n", PyString_AsString(str));
4053	Py_DECREF(str);
4054	return 0;
4055	}
4056
4057	SWIGINTERN void
4058	swig_varlink_dealloc(swig_varlinkobject *v) {
4059	swig_globalvar *var = v->vars;
4060	while (var) {
4061	swig_globalvar *n = var->next;
4062	free(var->name);
4063	free(var);
4064	var = n;
4065	}
4066	}
4067
4068	SWIGINTERN PyObject *
4069	swig_varlink_getattr(swig_varlinkobject v, char n) {
4070	PyObject *res = NULL;
4071	swig_globalvar *var = v->vars;
4072	while (var) {
4073	if (strcmp(var->name,n) == 0) {
4074	res = (*var->get_attr)();
4075	break;
4076	}
4077	var = var->next;
4078	}
4079	if (res == NULL && !PyErr_Occurred()) {
4080	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4081	}
4082	return res;
4083	}
4084
4085	SWIGINTERN int
4086	swig_varlink_setattr(swig_varlinkobject v, char n, PyObject *p) {
4087	int res = 1;
4088	swig_globalvar *var = v->vars;
4089	while (var) {
4090	if (strcmp(var->name,n) == 0) {
4091	res = (*var->set_attr)(p);
4092	break;
4093	}
4094	var = var->next;
4095	}
4096	if (res == 1 && !PyErr_Occurred()) {
4097	PyErr_SetString(PyExc_NameError,"Unknown C global variable");
4098	}
4099	return res;
4100	}
4101
4102	SWIGINTERN PyTypeObject*
4103	swig_varlink_type(void) {
4104	static char varlink__doc__[] = "Swig var link object";
4105	static PyTypeObject varlink_type;
4106	static int type_init = 0;
4107	if (!type_init) {
4108	const PyTypeObject tmp
4109	= {
4110	PyObject_HEAD_INIT(NULL)
4111	0, /* Number of items in variable part (ob_size) */
4112	(char )"swigvarlink", / Type name (tp_name) */
4113	sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
4114	0, /* Itemsize (tp_itemsize) */
4115	(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
4116	(printfunc) swig_varlink_print, /* Print (tp_print) */
4117	(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
4118	(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
4119	0, /* tp_compare */
4120	(reprfunc) swig_varlink_repr, /* tp_repr */
4121	0, /* tp_as_number */
4122	0, /* tp_as_sequence */
4123	0, /* tp_as_mapping */
4124	0, /* tp_hash */
4125	0, /* tp_call */
4126	(reprfunc)swig_varlink_str, /* tp_str */
4127	0, /* tp_getattro */
4128	0, /* tp_setattro */
4129	0, /* tp_as_buffer */
4130	0, /* tp_flags */
4131	varlink__doc__, /* tp_doc */
4132	0, /* tp_traverse */
4133	0, /* tp_clear */
4134	0, /* tp_richcompare */
4135	0, /* tp_weaklistoffset */
4136	#if PY_VERSION_HEX >= 0x02020000
4137	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
4138	#endif
4139	#if PY_VERSION_HEX >= 0x02030000
4140	0, /* tp_del */
4141	#endif
4142	#ifdef COUNT_ALLOCS
4143	0,0,0,0 /* tp_alloc -> tp_next */
4144	#endif
4145	};
4146	varlink_type = tmp;
4147	varlink_type.ob_type = &PyType_Type;
4148	type_init = 1;
4149	}
4150	return &varlink_type;
4151	}
4152
4153	/* Create a variable linking object for use later */
4154	SWIGINTERN PyObject *
4155	SWIG_Python_newvarlink(void) {
4156	swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
4157	if (result) {
4158	result->vars = 0;
4159	}
4160	return ((PyObject*) result);
4161	}
4162
4163	SWIGINTERN void
4164	SWIG_Python_addvarlink(PyObject p, char name, PyObject (get_attr)(void), int (set_attr)(PyObject p)) {
4165	swig_varlinkobject v = (swig_varlinkobject ) p;
4166	swig_globalvar gv = (swig_globalvar ) malloc(sizeof(swig_globalvar));
4167	if (gv) {
4168	size_t size = strlen(name)+1;
4169	gv->name = (char *)malloc(size);
4170	if (gv->name) {
4171	strncpy(gv->name,name,size);
4172	gv->get_attr = get_attr;
4173	gv->set_attr = set_attr;
4174	gv->next = v->vars;
4175	}
4176	}
4177	v->vars = gv;
4178	}
4179
4180	SWIGINTERN PyObject *
4181	SWIG_globals(void) {
4182	static PyObject *_SWIG_globals = 0;
4183	if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
4184	return _SWIG_globals;
4185	}
4186
4187	/* -----------------------------------------------------------------------------
4188	* constants/methods manipulation
4189	* ----------------------------------------------------------------------------- */
4190
4191	/* Install Constants */
4192	SWIGINTERN void
4193	SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
4194	PyObject *obj = 0;
4195	size_t i;
4196	for (i = 0; constants[i].type; ++i) {
4197	switch(constants[i].type) {
4198	case SWIG_PY_POINTER:
4199	obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
4200	break;
4201	case SWIG_PY_BINARY:
4202	obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
4203	break;
4204	default:
4205	obj = 0;
4206	break;
4207	}
4208	if (obj) {
4209	PyDict_SetItemString(d, constants[i].name, obj);
4210	Py_DECREF(obj);
4211	}
4212	}
4213	}
4214
4215	/* -----------------------------------------------------------------------------*/
4216	/* Fix SwigMethods to carry the callback ptrs when needed */
4217	/* -----------------------------------------------------------------------------*/
4218
4219	SWIGINTERN void
4220	SWIG_Python_FixMethods(PyMethodDef *methods,
4221	swig_const_info *const_table,
4222	swig_type_info **types,
4223	swig_type_info **types_initial) {
4224	size_t i;
4225	for (i = 0; methods[i].ml_name; ++i) {
4226	const char *c = methods[i].ml_doc;
4227	if (c && (c = strstr(c, "swig_ptr: "))) {
4228	int j;
4229	swig_const_info *ci = 0;
4230	const char *name = c + 10;
4231	for (j = 0; const_table[j].type; ++j) {
4232	if (strncmp(const_table[j].name, name,
4233	strlen(const_table[j].name)) == 0) {
4234	ci = &(const_table[j]);
4235	break;
4236	}
4237	}
4238	if (ci) {
4239	size_t shift = (ci->ptype) - types;
4240	swig_type_info *ty = types_initial[shift];
4241	size_t ldoc = (c - methods[i].ml_doc);
4242	size_t lptr = strlen(ty->name)+2sizeof(void)+2;
4243	char ndoc = (char)malloc(ldoc + lptr + 10);
4244	if (ndoc) {
4245	char *buff = ndoc;
4246	void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
4247	if (ptr) {
4248	strncpy(buff, methods[i].ml_doc, ldoc);
4249	buff += ldoc;
4250	strncpy(buff, "swig_ptr: ", 10);
4251	buff += 10;
4252	SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
4253	methods[i].ml_doc = ndoc;
4254	}
4255	}
4256	}
4257	}
4258	}
4259	}
4260
4261	#ifdef __cplusplus
4262	}
4263	#endif
4264
4265	/* -----------------------------------------------------------------------------*
4266	* Partial Init method
4267	* -----------------------------------------------------------------------------*/
4268
4269	#ifdef __cplusplus
4270	extern "C"
4271	#endif
4272	SWIGEXPORT void SWIG_init(void) {
4273	PyObject m, d;
4274
4275	/* Fix SwigMethods to carry the callback ptrs when needed */
4276	SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
4277
4278	m = Py_InitModule((char *) SWIG_name, SwigMethods);
4279	d = PyModule_GetDict(m);
4280
4281	SWIG_InitializeModule(0);
4282	SWIG_InstallConstants(d,swig_const_table);
4283
4284
4285	SWIG_Python_SetConstant(d, "REPLACE",SWIG_From_int((int)(TDB_REPLACE)));
4286	SWIG_Python_SetConstant(d, "INSERT",SWIG_From_int((int)(TDB_INSERT)));
4287	SWIG_Python_SetConstant(d, "MODIFY",SWIG_From_int((int)(TDB_MODIFY)));
4288	SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int((int)(TDB_DEFAULT)));
4289	SWIG_Python_SetConstant(d, "CLEAR_IF_FIRST",SWIG_From_int((int)(TDB_CLEAR_IF_FIRST)));
4290	SWIG_Python_SetConstant(d, "INTERNAL",SWIG_From_int((int)(TDB_INTERNAL)));
4291	SWIG_Python_SetConstant(d, "NOLOCK",SWIG_From_int((int)(TDB_NOLOCK)));
4292	SWIG_Python_SetConstant(d, "NOMMAP",SWIG_From_int((int)(TDB_NOMMAP)));
4293	SWIG_Python_SetConstant(d, "CONVERT",SWIG_From_int((int)(TDB_CONVERT)));
4294	SWIG_Python_SetConstant(d, "BIGENDIAN",SWIG_From_int((int)(TDB_BIGENDIAN)));
4295	SWIG_Python_SetConstant(d, "TDB_SUCCESS",SWIG_From_int((int)(TDB_SUCCESS)));
4296	SWIG_Python_SetConstant(d, "TDB_ERR_CORRUPT",SWIG_From_int((int)(TDB_ERR_CORRUPT)));
4297	SWIG_Python_SetConstant(d, "TDB_ERR_IO",SWIG_From_int((int)(TDB_ERR_IO)));
4298	SWIG_Python_SetConstant(d, "TDB_ERR_LOCK",SWIG_From_int((int)(TDB_ERR_LOCK)));
4299	SWIG_Python_SetConstant(d, "TDB_ERR_OOM",SWIG_From_int((int)(TDB_ERR_OOM)));
4300	SWIG_Python_SetConstant(d, "TDB_ERR_EXISTS",SWIG_From_int((int)(TDB_ERR_EXISTS)));
4301	SWIG_Python_SetConstant(d, "TDB_ERR_NOLOCK",SWIG_From_int((int)(TDB_ERR_NOLOCK)));
4302	SWIG_Python_SetConstant(d, "TDB_ERR_LOCK_TIMEOUT",SWIG_From_int((int)(TDB_ERR_LOCK_TIMEOUT)));
4303	SWIG_Python_SetConstant(d, "TDB_ERR_NOEXIST",SWIG_From_int((int)(TDB_ERR_NOEXIST)));
4304	SWIG_Python_SetConstant(d, "TDB_ERR_EINVAL",SWIG_From_int((int)(TDB_ERR_EINVAL)));
4305	SWIG_Python_SetConstant(d, "TDB_ERR_RDONLY",SWIG_From_int((int)(TDB_ERR_RDONLY)));
4306	}
4307

Note: See TracBrowser for help on using the repository browser.

Download in other formats: