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