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