~ubuntu-branches/ubuntu/maverick/speech-tools/maverick
» Revision
19
: wrappers/python/EST_Wave_wrap.cc
« back to all changes in this revision
Viewing changes to wrappers/python/EST_Wave_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_Wave_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_FVector swig_types[0]
2686
#define SWIGTYPE_p_EST_Item swig_types[1]
2687
#define SWIGTYPE_p_EST_Relation swig_types[2]
2688
#define SWIGTYPE_p_EST_Track swig_types[3]
2689
#define SWIGTYPE_p_EST_Wave swig_types[4]
2690
#define SWIGTYPE_p_EST_WaveList swig_types[5]
2691
#define SWIGTYPE_p_char swig_types[6]
2692
#define SWIGTYPE_p_short swig_types[7]
2693
static swig_type_info *swig_types[9];
2694
static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
2695
#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2696
#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2697
2698
/* -------- TYPES TABLE (END) -------- */
2699
2700
#if (PY_VERSION_HEX <= 0x02000000)
2701
# if !defined(SWIG_PYTHON_CLASSIC)
2702
# error "This python version requires swig to be run with the '-classic' option"
2703
# endif
2704
#endif
2705
2706
/*-----------------------------------------------
2707
@(target):= _EST_Wave.so
2708
------------------------------------------------*/
2709
#if PY_VERSION_HEX >= 0x03000000
2710
# define SWIG_init PyInit__EST_Wave
2711
2712
#else
2713
# define SWIG_init init_EST_Wave
2714
2715
#endif
2716
#define SWIG_name "_EST_Wave"
2717
2718
#define SWIGVERSION 0x010340
2719
#define SWIG_VERSION SWIGVERSION
2720
2721
2722
#define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2723
#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2724
2725
2726
#include <stdexcept>
2727
2728
2729
namespace swig {
2730
class SwigPtr_PyObject {
2731
protected:
2732
PyObject *_obj;
2733
2734
public:
2735
SwigPtr_PyObject() :_obj(0)
2736
{
2737
}
2738
2739
SwigPtr_PyObject(const SwigPtr_PyObject& item) : _obj(item._obj)
2740
{
2741
Py_XINCREF(_obj);
2742
}
2743
2744
SwigPtr_PyObject(PyObject *obj, bool initial_ref = true) :_obj(obj)
2745
{
2746
if (initial_ref) {
2747
Py_XINCREF(_obj);
2748
}
2749
}
2750
2751
SwigPtr_PyObject & operator=(const SwigPtr_PyObject& item)
2752
{
2753
Py_XINCREF(item._obj);
2754
Py_XDECREF(_obj);
2755
_obj = item._obj;
2756
return *this;
2757
}
2758
2759
~SwigPtr_PyObject()
2760
{
2761
Py_XDECREF(_obj);
2762
}
2763
2764
operator PyObject *() const
2765
{
2766
return _obj;
2767
}
2768
2769
PyObject *operator->() const
2770
{
2771
return _obj;
2772
}
2773
};
2774
}
2775
2776
2777
namespace swig {
2778
struct SwigVar_PyObject : SwigPtr_PyObject {
2779
SwigVar_PyObject(PyObject* obj = 0) : SwigPtr_PyObject(obj, false) { }
2780
2781
SwigVar_PyObject & operator = (PyObject* obj)
2782
{
2783
Py_XDECREF(_obj);
2784
_obj = obj;
2785
return *this;
2786
}
2787
};
2788
}
2789
2790
2791
#include "EST_Wave.h"
2792
#include "EST_wave_aux.h"
2793
#include "EST_audio.h"
2794
#include "EST_Option.h"
2795
2796
2797
#include "EST_rw_status.h"
2798
2799
2800
#define SWIG_From_long PyInt_FromLong
2801
2802
2803
SWIGINTERNINLINE PyObject *
2804
SWIG_From_int (int value)
2805
{
2806
return SWIG_From_long (value);
2807
}
2808
2809
2810
#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
2811
typedef int Py_ssize_t;
2812
#define PY_SSIZE_T_MAX INT_MAX
2813
#define PY_SSIZE_T_MIN INT_MIN
2814
#endif
2815
2816
2817
#include <limits.h>
2818
#if !defined(SWIG_NO_LLONG_MAX)
2819
# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
2820
# define LLONG_MAX __LONG_LONG_MAX__
2821
# define LLONG_MIN (-LLONG_MAX - 1LL)
2822
# define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
2823
# endif
2824
#endif
2825
2826
2827
SWIGINTERN int
2828
SWIG_AsVal_double (PyObject *obj, double *val)
2829
{
2830
int res = SWIG_TypeError;
2831
if (PyFloat_Check(obj)) {
2832
if (val) *val = PyFloat_AsDouble(obj);
2833
return SWIG_OK;
2834
} else if (PyInt_Check(obj)) {
2835
if (val) *val = PyInt_AsLong(obj);
2836
return SWIG_OK;
2837
} else if (PyLong_Check(obj)) {
2838
double v = PyLong_AsDouble(obj);
2839
if (!PyErr_Occurred()) {
2840
if (val) *val = v;
2841
return SWIG_OK;
2842
} else {
2843
PyErr_Clear();
2844
}
2845
}
2846
#ifdef SWIG_PYTHON_CAST_MODE
2847
{
2848
int dispatch = 0;
2849
double d = PyFloat_AsDouble(obj);
2850
if (!PyErr_Occurred()) {
2851
if (val) *val = d;
2852
return SWIG_AddCast(SWIG_OK);
2853
} else {
2854
PyErr_Clear();
2855
}
2856
if (!dispatch) {
2857
long v = PyLong_AsLong(obj);
2858
if (!PyErr_Occurred()) {
2859
if (val) *val = v;
2860
return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
2861
} else {
2862
PyErr_Clear();
2863
}
2864
}
2865
}
2866
#endif
2867
return res;
2868
}
2869
2870
2871
#include <float.h>
2872
2873
2874
#include <math.h>
2875
2876
2877
SWIGINTERNINLINE int
2878
SWIG_CanCastAsInteger(double *d, double min, double max) {
2879
double x = *d;
2880
if ((min <= x && x <= max)) {
2881
double fx = floor(x);
2882
double cx = ceil(x);
2883
double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
2884
if ((errno == EDOM) || (errno == ERANGE)) {
2885
errno = 0;
2886
} else {
2887
double summ, reps, diff;
2888
if (rd < x) {
2889
diff = x - rd;
2890
} else if (rd > x) {
2891
diff = rd - x;
2892
} else {
2893
return 1;
2894
}
2895
summ = rd + x;
2896
reps = diff/summ;
2897
if (reps < 8*DBL_EPSILON) {
2898
*d = rd;
2899
return 1;
2900
}
2901
}
2902
}
2903
return 0;
2904
}
2905
2906
2907
SWIGINTERN int
2908
SWIG_AsVal_long (PyObject *obj, long* val)
2909
{
2910
if (PyInt_Check(obj)) {
2911
if (val) *val = PyInt_AsLong(obj);
2912
return SWIG_OK;
2913
} else if (PyLong_Check(obj)) {
2914
long v = PyLong_AsLong(obj);
2915
if (!PyErr_Occurred()) {
2916
if (val) *val = v;
2917
return SWIG_OK;
2918
} else {
2919
PyErr_Clear();
2920
}
2921
}
2922
#ifdef SWIG_PYTHON_CAST_MODE
2923
{
2924
int dispatch = 0;
2925
long v = PyInt_AsLong(obj);
2926
if (!PyErr_Occurred()) {
2927
if (val) *val = v;
2928
return SWIG_AddCast(SWIG_OK);
2929
} else {
2930
PyErr_Clear();
2931
}
2932
if (!dispatch) {
2933
double d;
2934
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
2935
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
2936
if (val) *val = (long)(d);
2937
return res;
2938
}
2939
}
2940
}
2941
#endif
2942
return SWIG_TypeError;
2943
}
2944
2945
2946
SWIGINTERN int
2947
SWIG_AsVal_int (PyObject * obj, int *val)
2948
{
2949
long v;
2950
int res = SWIG_AsVal_long (obj, &v);
2951
if (SWIG_IsOK(res)) {
2952
if ((v < INT_MIN || v > INT_MAX)) {
2953
return SWIG_OverflowError;
2954
} else {
2955
if (val) *val = static_cast< int >(v);
2956
}
2957
}
2958
return res;
2959
}
2960
2961
2962
SWIGINTERNINLINE PyObject *
2963
SWIG_From_short (short value)
2964
{
2965
return SWIG_From_long (value);
2966
}
2967
2968
2969
SWIGINTERN int
2970
SWIG_AsVal_short (PyObject * obj, short *val)
2971
{
2972
long v;
2973
int res = SWIG_AsVal_long (obj, &v);
2974
if (SWIG_IsOK(res)) {
2975
if ((v < SHRT_MIN || v > SHRT_MAX)) {
2976
return SWIG_OverflowError;
2977
} else {
2978
if (val) *val = static_cast< short >(v);
2979
}
2980
}
2981
return res;
2982
}
2983
2984
2985
#define SWIG_From_double PyFloat_FromDouble
2986
2987
2988
SWIGINTERNINLINE PyObject *
2989
SWIG_From_float (float value)
2990
{
2991
return SWIG_From_double (value);
2992
}
2993
2994
2995
SWIGINTERN int
2996
SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
2997
{
2998
if (PyInt_Check(obj)) {
2999
long v = PyInt_AsLong(obj);
3000
if (v >= 0) {
3001
if (val) *val = v;
3002
return SWIG_OK;
3003
} else {
3004
return SWIG_OverflowError;
3005
}
3006
} else if (PyLong_Check(obj)) {
3007
unsigned long v = PyLong_AsUnsignedLong(obj);
3008
if (!PyErr_Occurred()) {
3009
if (val) *val = v;
3010
return SWIG_OK;
3011
} else {
3012
PyErr_Clear();
3013
}
3014
}
3015
#ifdef SWIG_PYTHON_CAST_MODE
3016
{
3017
int dispatch = 0;
3018
unsigned long v = PyLong_AsUnsignedLong(obj);
3019
if (!PyErr_Occurred()) {
3020
if (val) *val = v;
3021
return SWIG_AddCast(SWIG_OK);
3022
} else {
3023
PyErr_Clear();
3024
}
3025
if (!dispatch) {
3026
double d;
3027
int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3028
if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3029
if (val) *val = (unsigned long)(d);
3030
return res;
3031
}
3032
}
3033
}
3034
#endif
3035
return SWIG_TypeError;
3036
}
3037
3038
3039
SWIGINTERN int
3040
SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3041
{
3042
unsigned long v;
3043
int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3044
if (SWIG_IsOK(res)) {
3045
if ((v > UINT_MAX)) {
3046
return SWIG_OverflowError;
3047
} else {
3048
if (val) *val = static_cast< unsigned int >(v);
3049
}
3050
}
3051
return res;
3052
}
3053
3054
3055
SWIGINTERNINLINE PyObject*
3056
SWIG_From_bool (bool value)
3057
{
3058
return PyBool_FromLong(value ? 1 : 0);
3059
}
3060
3061
3062
SWIGINTERN swig_type_info*
3063
SWIG_pchar_descriptor(void)
3064
{
3065
static int init = 0;
3066
static swig_type_info* info = 0;
3067
if (!init) {
3068
info = SWIG_TypeQuery("_p_char");
3069
init = 1;
3070
}
3071
return info;
3072
}
3073
3074
3075
SWIGINTERN int
3076
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3077
{
3078
#if PY_VERSION_HEX>=0x03000000
3079
if (PyUnicode_Check(obj))
3080
#else
3081
if (PyString_Check(obj))
3082
#endif
3083
{
3084
char *cstr; Py_ssize_t len;
3085
#if PY_VERSION_HEX>=0x03000000
3086
if (!alloc && cptr) {
3087
/* We can't allow converting without allocation, since the internal
3088
representation of string in Python 3 is UCS-2/UCS-4 but we require
3089
a UTF-8 representation.
3090
TODO(bhy) More detailed explanation */
3091
return SWIG_RuntimeError;
3092
}
3093
obj = PyUnicode_AsUTF8String(obj);
3094
PyBytes_AsStringAndSize(obj, &cstr, &len);
3095
if(alloc) *alloc = SWIG_NEWOBJ;
3096
#else
3097
PyString_AsStringAndSize(obj, &cstr, &len);
3098
#endif
3099
if (cptr) {
3100
if (alloc) {
3101
/*
3102
In python the user should not be able to modify the inner
3103
string representation. To warranty that, if you define
3104
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3105
buffer is always returned.
3106
3107
The default behavior is just to return the pointer value,
3108
so, be careful.
3109
*/
3110
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3111
if (*alloc != SWIG_OLDOBJ)
3112
#else
3113
if (*alloc == SWIG_NEWOBJ)
3114
#endif
3115
{
3116
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3117
*alloc = SWIG_NEWOBJ;
3118
}
3119
else {
3120
*cptr = cstr;
3121
*alloc = SWIG_OLDOBJ;
3122
}
3123
} else {
3124
#if PY_VERSION_HEX>=0x03000000
3125
assert(0); /* Should never reach here in Python 3 */
3126
#endif
3127
*cptr = SWIG_Python_str_AsChar(obj);
3128
}
3129
}
3130
if (psize) *psize = len + 1;
3131
#if PY_VERSION_HEX>=0x03000000
3132
Py_XDECREF(obj);
3133
#endif
3134
return SWIG_OK;
3135
} else {
3136
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3137
if (pchar_descriptor) {
3138
void* vptr = 0;
3139
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3140
if (cptr) *cptr = (char *) vptr;
3141
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3142
if (alloc) *alloc = SWIG_OLDOBJ;
3143
return SWIG_OK;
3144
}
3145
}
3146
}
3147
return SWIG_TypeError;
3148
}
3149
3150
3151
3152
3153
3154
SWIGINTERN int
3155
SWIG_AsVal_float (PyObject * obj, float *val)
3156
{
3157
double v;
3158
int res = SWIG_AsVal_double (obj, &v);
3159
if (SWIG_IsOK(res)) {
3160
if ((v < -FLT_MAX || v > FLT_MAX)) {
3161
return SWIG_OverflowError;
3162
} else {
3163
if (val) *val = static_cast< float >(v);
3164
}
3165
}
3166
return res;
3167
}
3168
3169
SWIGINTERN void EST_Wave_info(EST_Wave *self){
3170
wave_info( *self );
3171
}
3172
SWIGINTERN void EST_Wave_play(EST_Wave *self){
3173
EST_Option empty;
3174
play_wave( *self, empty );
3175
}
3176
#ifdef __cplusplus
3177
extern "C" {
3178
#endif
3179
SWIGINTERN PyObject *_wrap_EST_Wave_default_sample_rate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3180
PyObject *resultobj = 0;
3181
EST_Wave *arg1 = (EST_Wave *) 0 ;
3182
void *argp1 = 0 ;
3183
int res1 = 0 ;
3184
PyObject * obj0 = 0 ;
3185
int result;
3186
3187
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_default_sample_rate_get",&obj0)) SWIG_fail;
3188
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3189
if (!SWIG_IsOK(res1)) {
3190
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_default_sample_rate_get" "', argument " "1"" of type '" "EST_Wave *""'");
3191
}
3192
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3193
result = (int)(int) ((arg1)->default_sample_rate);
3194
resultobj = SWIG_From_int(static_cast< int >(result));
3195
return resultobj;
3196
fail:
3197
return NULL;
3198
}
3199
3200
3201
SWIGINTERN PyObject *_wrap_new_EST_Wave__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3202
PyObject *resultobj = 0;
3203
EST_Wave *result = 0 ;
3204
3205
if (!PyArg_ParseTuple(args,(char *)":new_EST_Wave")) SWIG_fail;
3206
result = (EST_Wave *)new EST_Wave();
3207
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_Wave, SWIG_POINTER_NEW | 0 );
3208
return resultobj;
3209
fail:
3210
return NULL;
3211
}
3212
3213
3214
SWIGINTERN PyObject *_wrap_new_EST_Wave__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3215
PyObject *resultobj = 0;
3216
EST_Wave *arg1 = 0 ;
3217
void *argp1 = 0 ;
3218
int res1 = 0 ;
3219
PyObject * obj0 = 0 ;
3220
EST_Wave *result = 0 ;
3221
3222
if (!PyArg_ParseTuple(args,(char *)"O:new_EST_Wave",&obj0)) SWIG_fail;
3223
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 | 0);
3224
if (!SWIG_IsOK(res1)) {
3225
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EST_Wave" "', argument " "1"" of type '" "EST_Wave const &""'");
3226
}
3227
if (!argp1) {
3228
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_EST_Wave" "', argument " "1"" of type '" "EST_Wave const &""'");
3229
}
3230
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3231
result = (EST_Wave *)new EST_Wave((EST_Wave const &)*arg1);
3232
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_Wave, SWIG_POINTER_NEW | 0 );
3233
return resultobj;
3234
fail:
3235
return NULL;
3236
}
3237
3238
3239
SWIGINTERN PyObject *_wrap_new_EST_Wave__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3240
PyObject *resultobj = 0;
3241
int arg1 ;
3242
int arg2 ;
3243
int arg3 ;
3244
int val1 ;
3245
int ecode1 = 0 ;
3246
int val2 ;
3247
int ecode2 = 0 ;
3248
int val3 ;
3249
int ecode3 = 0 ;
3250
PyObject * obj0 = 0 ;
3251
PyObject * obj1 = 0 ;
3252
PyObject * obj2 = 0 ;
3253
EST_Wave *result = 0 ;
3254
3255
if (!PyArg_ParseTuple(args,(char *)"OOO:new_EST_Wave",&obj0,&obj1,&obj2)) SWIG_fail;
3256
ecode1 = SWIG_AsVal_int(obj0, &val1);
3257
if (!SWIG_IsOK(ecode1)) {
3258
SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EST_Wave" "', argument " "1"" of type '" "int""'");
3259
}
3260
arg1 = static_cast< int >(val1);
3261
ecode2 = SWIG_AsVal_int(obj1, &val2);
3262
if (!SWIG_IsOK(ecode2)) {
3263
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EST_Wave" "', argument " "2"" of type '" "int""'");
3264
}
3265
arg2 = static_cast< int >(val2);
3266
ecode3 = SWIG_AsVal_int(obj2, &val3);
3267
if (!SWIG_IsOK(ecode3)) {
3268
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EST_Wave" "', argument " "3"" of type '" "int""'");
3269
}
3270
arg3 = static_cast< int >(val3);
3271
result = (EST_Wave *)new EST_Wave(arg1,arg2,arg3);
3272
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_EST_Wave, SWIG_POINTER_NEW | 0 );
3273
return resultobj;
3274
fail:
3275
return NULL;
3276
}
3277
3278
3279
SWIGINTERN PyObject *_wrap_new_EST_Wave(PyObject *self, PyObject *args) {
3280
int argc;
3281
PyObject *argv[4];
3282
int ii;
3283
3284
if (!PyTuple_Check(args)) SWIG_fail;
3285
argc = (int)PyObject_Length(args);
3286
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3287
argv[ii] = PyTuple_GET_ITEM(args,ii);
3288
}
3289
if (argc == 0) {
3290
return _wrap_new_EST_Wave__SWIG_0(self, args);
3291
}
3292
if (argc == 1) {
3293
int _v;
3294
int res = SWIG_ConvertPtr(argv[0], 0, SWIGTYPE_p_EST_Wave, 0);
3295
_v = SWIG_CheckState(res);
3296
if (_v) {
3297
return _wrap_new_EST_Wave__SWIG_1(self, args);
3298
}
3299
}
3300
if (argc == 3) {
3301
int _v;
3302
{
3303
int res = SWIG_AsVal_int(argv[0], NULL);
3304
_v = SWIG_CheckState(res);
3305
}
3306
if (_v) {
3307
{
3308
int res = SWIG_AsVal_int(argv[1], NULL);
3309
_v = SWIG_CheckState(res);
3310
}
3311
if (_v) {
3312
{
3313
int res = SWIG_AsVal_int(argv[2], NULL);
3314
_v = SWIG_CheckState(res);
3315
}
3316
if (_v) {
3317
return _wrap_new_EST_Wave__SWIG_2(self, args);
3318
}
3319
}
3320
}
3321
}
3322
3323
fail:
3324
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'new_EST_Wave'.\n"
3325
" Possible C/C++ prototypes are:\n"
3326
" EST_Wave()\n"
3327
" EST_Wave(EST_Wave const &)\n"
3328
" EST_Wave(int,int,int)\n");
3329
return NULL;
3330
}
3331
3332
3333
SWIGINTERN PyObject *_wrap_delete_EST_Wave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3334
PyObject *resultobj = 0;
3335
EST_Wave *arg1 = (EST_Wave *) 0 ;
3336
void *argp1 = 0 ;
3337
int res1 = 0 ;
3338
PyObject * obj0 = 0 ;
3339
3340
if (!PyArg_ParseTuple(args,(char *)"O:delete_EST_Wave",&obj0)) SWIG_fail;
3341
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, SWIG_POINTER_DISOWN | 0 );
3342
if (!SWIG_IsOK(res1)) {
3343
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EST_Wave" "', argument " "1"" of type '" "EST_Wave *""'");
3344
}
3345
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3346
delete arg1;
3347
resultobj = SWIG_Py_Void();
3348
return resultobj;
3349
fail:
3350
return NULL;
3351
}
3352
3353
3354
SWIGINTERN PyObject *_wrap_EST_Wave_a__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3355
PyObject *resultobj = 0;
3356
EST_Wave *arg1 = (EST_Wave *) 0 ;
3357
int arg2 ;
3358
int arg3 ;
3359
void *argp1 = 0 ;
3360
int res1 = 0 ;
3361
int val2 ;
3362
int ecode2 = 0 ;
3363
int val3 ;
3364
int ecode3 = 0 ;
3365
PyObject * obj0 = 0 ;
3366
PyObject * obj1 = 0 ;
3367
PyObject * obj2 = 0 ;
3368
short result;
3369
3370
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_a",&obj0,&obj1,&obj2)) SWIG_fail;
3371
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3372
if (!SWIG_IsOK(res1)) {
3373
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_a" "', argument " "1"" of type '" "EST_Wave const *""'");
3374
}
3375
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3376
ecode2 = SWIG_AsVal_int(obj1, &val2);
3377
if (!SWIG_IsOK(ecode2)) {
3378
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_a" "', argument " "2"" of type '" "int""'");
3379
}
3380
arg2 = static_cast< int >(val2);
3381
ecode3 = SWIG_AsVal_int(obj2, &val3);
3382
if (!SWIG_IsOK(ecode3)) {
3383
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_a" "', argument " "3"" of type '" "int""'");
3384
}
3385
arg3 = static_cast< int >(val3);
3386
result = (short)((EST_Wave const *)arg1)->a(arg2,arg3);
3387
resultobj = SWIG_From_short(static_cast< short >(result));
3388
return resultobj;
3389
fail:
3390
return NULL;
3391
}
3392
3393
3394
SWIGINTERN PyObject *_wrap_EST_Wave_a__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3395
PyObject *resultobj = 0;
3396
EST_Wave *arg1 = (EST_Wave *) 0 ;
3397
int arg2 ;
3398
void *argp1 = 0 ;
3399
int res1 = 0 ;
3400
int val2 ;
3401
int ecode2 = 0 ;
3402
PyObject * obj0 = 0 ;
3403
PyObject * obj1 = 0 ;
3404
short result;
3405
3406
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_a",&obj0,&obj1)) SWIG_fail;
3407
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3408
if (!SWIG_IsOK(res1)) {
3409
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_a" "', argument " "1"" of type '" "EST_Wave const *""'");
3410
}
3411
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3412
ecode2 = SWIG_AsVal_int(obj1, &val2);
3413
if (!SWIG_IsOK(ecode2)) {
3414
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_a" "', argument " "2"" of type '" "int""'");
3415
}
3416
arg2 = static_cast< int >(val2);
3417
result = (short)((EST_Wave const *)arg1)->a(arg2);
3418
resultobj = SWIG_From_short(static_cast< short >(result));
3419
return resultobj;
3420
fail:
3421
return NULL;
3422
}
3423
3424
3425
SWIGINTERN PyObject *_wrap_EST_Wave_a(PyObject *self, PyObject *args) {
3426
int argc;
3427
PyObject *argv[4];
3428
int ii;
3429
3430
if (!PyTuple_Check(args)) SWIG_fail;
3431
argc = (int)PyObject_Length(args);
3432
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3433
argv[ii] = PyTuple_GET_ITEM(args,ii);
3434
}
3435
if (argc == 2) {
3436
int _v;
3437
void *vptr = 0;
3438
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3439
_v = SWIG_CheckState(res);
3440
if (_v) {
3441
{
3442
int res = SWIG_AsVal_int(argv[1], NULL);
3443
_v = SWIG_CheckState(res);
3444
}
3445
if (_v) {
3446
return _wrap_EST_Wave_a__SWIG_1(self, args);
3447
}
3448
}
3449
}
3450
if (argc == 3) {
3451
int _v;
3452
void *vptr = 0;
3453
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3454
_v = SWIG_CheckState(res);
3455
if (_v) {
3456
{
3457
int res = SWIG_AsVal_int(argv[1], NULL);
3458
_v = SWIG_CheckState(res);
3459
}
3460
if (_v) {
3461
{
3462
int res = SWIG_AsVal_int(argv[2], NULL);
3463
_v = SWIG_CheckState(res);
3464
}
3465
if (_v) {
3466
return _wrap_EST_Wave_a__SWIG_0(self, args);
3467
}
3468
}
3469
}
3470
}
3471
3472
fail:
3473
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_a'.\n"
3474
" Possible C/C++ prototypes are:\n"
3475
" a(EST_Wave const *,int,int)\n"
3476
" a(EST_Wave const *,int)\n");
3477
return NULL;
3478
}
3479
3480
3481
SWIGINTERN PyObject *_wrap_EST_Wave_a_safe__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3482
PyObject *resultobj = 0;
3483
EST_Wave *arg1 = (EST_Wave *) 0 ;
3484
int arg2 ;
3485
int arg3 ;
3486
void *argp1 = 0 ;
3487
int res1 = 0 ;
3488
int val2 ;
3489
int ecode2 = 0 ;
3490
int val3 ;
3491
int ecode3 = 0 ;
3492
PyObject * obj0 = 0 ;
3493
PyObject * obj1 = 0 ;
3494
PyObject * obj2 = 0 ;
3495
short *result = 0 ;
3496
3497
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_a_safe",&obj0,&obj1,&obj2)) SWIG_fail;
3498
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3499
if (!SWIG_IsOK(res1)) {
3500
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_a_safe" "', argument " "1"" of type '" "EST_Wave *""'");
3501
}
3502
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3503
ecode2 = SWIG_AsVal_int(obj1, &val2);
3504
if (!SWIG_IsOK(ecode2)) {
3505
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_a_safe" "', argument " "2"" of type '" "int""'");
3506
}
3507
arg2 = static_cast< int >(val2);
3508
ecode3 = SWIG_AsVal_int(obj2, &val3);
3509
if (!SWIG_IsOK(ecode3)) {
3510
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_a_safe" "', argument " "3"" of type '" "int""'");
3511
}
3512
arg3 = static_cast< int >(val3);
3513
result = (short *) &(arg1)->a_safe(arg2,arg3);
3514
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
3515
return resultobj;
3516
fail:
3517
return NULL;
3518
}
3519
3520
3521
SWIGINTERN PyObject *_wrap_EST_Wave_a_safe__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3522
PyObject *resultobj = 0;
3523
EST_Wave *arg1 = (EST_Wave *) 0 ;
3524
int arg2 ;
3525
void *argp1 = 0 ;
3526
int res1 = 0 ;
3527
int val2 ;
3528
int ecode2 = 0 ;
3529
PyObject * obj0 = 0 ;
3530
PyObject * obj1 = 0 ;
3531
short *result = 0 ;
3532
3533
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_a_safe",&obj0,&obj1)) SWIG_fail;
3534
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3535
if (!SWIG_IsOK(res1)) {
3536
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_a_safe" "', argument " "1"" of type '" "EST_Wave *""'");
3537
}
3538
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3539
ecode2 = SWIG_AsVal_int(obj1, &val2);
3540
if (!SWIG_IsOK(ecode2)) {
3541
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_a_safe" "', argument " "2"" of type '" "int""'");
3542
}
3543
arg2 = static_cast< int >(val2);
3544
result = (short *) &(arg1)->a_safe(arg2);
3545
resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_short, 0 | 0 );
3546
return resultobj;
3547
fail:
3548
return NULL;
3549
}
3550
3551
3552
SWIGINTERN PyObject *_wrap_EST_Wave_a_safe(PyObject *self, PyObject *args) {
3553
int argc;
3554
PyObject *argv[4];
3555
int ii;
3556
3557
if (!PyTuple_Check(args)) SWIG_fail;
3558
argc = (int)PyObject_Length(args);
3559
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
3560
argv[ii] = PyTuple_GET_ITEM(args,ii);
3561
}
3562
if (argc == 2) {
3563
int _v;
3564
void *vptr = 0;
3565
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3566
_v = SWIG_CheckState(res);
3567
if (_v) {
3568
{
3569
int res = SWIG_AsVal_int(argv[1], NULL);
3570
_v = SWIG_CheckState(res);
3571
}
3572
if (_v) {
3573
return _wrap_EST_Wave_a_safe__SWIG_1(self, args);
3574
}
3575
}
3576
}
3577
if (argc == 3) {
3578
int _v;
3579
void *vptr = 0;
3580
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3581
_v = SWIG_CheckState(res);
3582
if (_v) {
3583
{
3584
int res = SWIG_AsVal_int(argv[1], NULL);
3585
_v = SWIG_CheckState(res);
3586
}
3587
if (_v) {
3588
{
3589
int res = SWIG_AsVal_int(argv[2], NULL);
3590
_v = SWIG_CheckState(res);
3591
}
3592
if (_v) {
3593
return _wrap_EST_Wave_a_safe__SWIG_0(self, args);
3594
}
3595
}
3596
}
3597
}
3598
3599
fail:
3600
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_a_safe'.\n"
3601
" Possible C/C++ prototypes are:\n"
3602
" a_safe(EST_Wave *,int,int)\n"
3603
" a_safe(EST_Wave *,int)\n");
3604
return NULL;
3605
}
3606
3607
3608
SWIGINTERN PyObject *_wrap_EST_Wave_set_a__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3609
PyObject *resultobj = 0;
3610
EST_Wave *arg1 = (EST_Wave *) 0 ;
3611
int arg2 ;
3612
int arg3 ;
3613
short arg4 ;
3614
void *argp1 = 0 ;
3615
int res1 = 0 ;
3616
int val2 ;
3617
int ecode2 = 0 ;
3618
int val3 ;
3619
int ecode3 = 0 ;
3620
short val4 ;
3621
int ecode4 = 0 ;
3622
PyObject * obj0 = 0 ;
3623
PyObject * obj1 = 0 ;
3624
PyObject * obj2 = 0 ;
3625
PyObject * obj3 = 0 ;
3626
short result;
3627
3628
if (!PyArg_ParseTuple(args,(char *)"OOOO:EST_Wave_set_a",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
3629
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3630
if (!SWIG_IsOK(res1)) {
3631
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_a" "', argument " "1"" of type '" "EST_Wave *""'");
3632
}
3633
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3634
ecode2 = SWIG_AsVal_int(obj1, &val2);
3635
if (!SWIG_IsOK(ecode2)) {
3636
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_set_a" "', argument " "2"" of type '" "int""'");
3637
}
3638
arg2 = static_cast< int >(val2);
3639
ecode3 = SWIG_AsVal_int(obj2, &val3);
3640
if (!SWIG_IsOK(ecode3)) {
3641
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_set_a" "', argument " "3"" of type '" "int""'");
3642
}
3643
arg3 = static_cast< int >(val3);
3644
ecode4 = SWIG_AsVal_short(obj3, &val4);
3645
if (!SWIG_IsOK(ecode4)) {
3646
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_set_a" "', argument " "4"" of type '" "short""'");
3647
}
3648
arg4 = static_cast< short >(val4);
3649
result = (short)(arg1)->set_a(arg2,arg3,arg4);
3650
resultobj = SWIG_From_short(static_cast< short >(result));
3651
return resultobj;
3652
fail:
3653
return NULL;
3654
}
3655
3656
3657
SWIGINTERN PyObject *_wrap_EST_Wave_set_a__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3658
PyObject *resultobj = 0;
3659
EST_Wave *arg1 = (EST_Wave *) 0 ;
3660
int arg2 ;
3661
int arg3 ;
3662
void *argp1 = 0 ;
3663
int res1 = 0 ;
3664
int val2 ;
3665
int ecode2 = 0 ;
3666
int val3 ;
3667
int ecode3 = 0 ;
3668
PyObject * obj0 = 0 ;
3669
PyObject * obj1 = 0 ;
3670
PyObject * obj2 = 0 ;
3671
short result;
3672
3673
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_set_a",&obj0,&obj1,&obj2)) SWIG_fail;
3674
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3675
if (!SWIG_IsOK(res1)) {
3676
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_a" "', argument " "1"" of type '" "EST_Wave *""'");
3677
}
3678
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3679
ecode2 = SWIG_AsVal_int(obj1, &val2);
3680
if (!SWIG_IsOK(ecode2)) {
3681
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_set_a" "', argument " "2"" of type '" "int""'");
3682
}
3683
arg2 = static_cast< int >(val2);
3684
ecode3 = SWIG_AsVal_int(obj2, &val3);
3685
if (!SWIG_IsOK(ecode3)) {
3686
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_set_a" "', argument " "3"" of type '" "int""'");
3687
}
3688
arg3 = static_cast< int >(val3);
3689
result = (short)(arg1)->set_a(arg2,arg3);
3690
resultobj = SWIG_From_short(static_cast< short >(result));
3691
return resultobj;
3692
fail:
3693
return NULL;
3694
}
3695
3696
3697
SWIGINTERN PyObject *_wrap_EST_Wave_set_a__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3698
PyObject *resultobj = 0;
3699
EST_Wave *arg1 = (EST_Wave *) 0 ;
3700
int arg2 ;
3701
void *argp1 = 0 ;
3702
int res1 = 0 ;
3703
int val2 ;
3704
int ecode2 = 0 ;
3705
PyObject * obj0 = 0 ;
3706
PyObject * obj1 = 0 ;
3707
short result;
3708
3709
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_set_a",&obj0,&obj1)) SWIG_fail;
3710
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3711
if (!SWIG_IsOK(res1)) {
3712
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_a" "', argument " "1"" of type '" "EST_Wave *""'");
3713
}
3714
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3715
ecode2 = SWIG_AsVal_int(obj1, &val2);
3716
if (!SWIG_IsOK(ecode2)) {
3717
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_set_a" "', argument " "2"" of type '" "int""'");
3718
}
3719
arg2 = static_cast< int >(val2);
3720
result = (short)(arg1)->set_a(arg2);
3721
resultobj = SWIG_From_short(static_cast< short >(result));
3722
return resultobj;
3723
fail:
3724
return NULL;
3725
}
3726
3727
3728
SWIGINTERN PyObject *_wrap_EST_Wave_set_a(PyObject *self, PyObject *args) {
3729
int argc;
3730
PyObject *argv[5];
3731
int ii;
3732
3733
if (!PyTuple_Check(args)) SWIG_fail;
3734
argc = (int)PyObject_Length(args);
3735
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
3736
argv[ii] = PyTuple_GET_ITEM(args,ii);
3737
}
3738
if (argc == 2) {
3739
int _v;
3740
void *vptr = 0;
3741
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3742
_v = SWIG_CheckState(res);
3743
if (_v) {
3744
{
3745
int res = SWIG_AsVal_int(argv[1], NULL);
3746
_v = SWIG_CheckState(res);
3747
}
3748
if (_v) {
3749
return _wrap_EST_Wave_set_a__SWIG_2(self, args);
3750
}
3751
}
3752
}
3753
if (argc == 3) {
3754
int _v;
3755
void *vptr = 0;
3756
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3757
_v = SWIG_CheckState(res);
3758
if (_v) {
3759
{
3760
int res = SWIG_AsVal_int(argv[1], NULL);
3761
_v = SWIG_CheckState(res);
3762
}
3763
if (_v) {
3764
{
3765
int res = SWIG_AsVal_int(argv[2], NULL);
3766
_v = SWIG_CheckState(res);
3767
}
3768
if (_v) {
3769
return _wrap_EST_Wave_set_a__SWIG_1(self, args);
3770
}
3771
}
3772
}
3773
}
3774
if (argc == 4) {
3775
int _v;
3776
void *vptr = 0;
3777
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
3778
_v = SWIG_CheckState(res);
3779
if (_v) {
3780
{
3781
int res = SWIG_AsVal_int(argv[1], NULL);
3782
_v = SWIG_CheckState(res);
3783
}
3784
if (_v) {
3785
{
3786
int res = SWIG_AsVal_int(argv[2], NULL);
3787
_v = SWIG_CheckState(res);
3788
}
3789
if (_v) {
3790
{
3791
int res = SWIG_AsVal_short(argv[3], NULL);
3792
_v = SWIG_CheckState(res);
3793
}
3794
if (_v) {
3795
return _wrap_EST_Wave_set_a__SWIG_0(self, args);
3796
}
3797
}
3798
}
3799
}
3800
}
3801
3802
fail:
3803
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_set_a'.\n"
3804
" Possible C/C++ prototypes are:\n"
3805
" set_a(EST_Wave *,int,int,short)\n"
3806
" set_a(EST_Wave *,int,int)\n"
3807
" set_a(EST_Wave *,int)\n");
3808
return NULL;
3809
}
3810
3811
3812
SWIGINTERN PyObject *_wrap_EST_Wave_t(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3813
PyObject *resultobj = 0;
3814
EST_Wave *arg1 = (EST_Wave *) 0 ;
3815
int arg2 ;
3816
void *argp1 = 0 ;
3817
int res1 = 0 ;
3818
int val2 ;
3819
int ecode2 = 0 ;
3820
PyObject * obj0 = 0 ;
3821
PyObject * obj1 = 0 ;
3822
float result;
3823
3824
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_t",&obj0,&obj1)) SWIG_fail;
3825
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3826
if (!SWIG_IsOK(res1)) {
3827
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_t" "', argument " "1"" of type '" "EST_Wave const *""'");
3828
}
3829
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3830
ecode2 = SWIG_AsVal_int(obj1, &val2);
3831
if (!SWIG_IsOK(ecode2)) {
3832
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_t" "', argument " "2"" of type '" "int""'");
3833
}
3834
arg2 = static_cast< int >(val2);
3835
result = (float)((EST_Wave const *)arg1)->t(arg2);
3836
resultobj = SWIG_From_float(static_cast< float >(result));
3837
return resultobj;
3838
fail:
3839
return NULL;
3840
}
3841
3842
3843
SWIGINTERN PyObject *_wrap_EST_Wave_num_samples(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3844
PyObject *resultobj = 0;
3845
EST_Wave *arg1 = (EST_Wave *) 0 ;
3846
void *argp1 = 0 ;
3847
int res1 = 0 ;
3848
PyObject * obj0 = 0 ;
3849
int result;
3850
3851
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_num_samples",&obj0)) SWIG_fail;
3852
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3853
if (!SWIG_IsOK(res1)) {
3854
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_num_samples" "', argument " "1"" of type '" "EST_Wave const *""'");
3855
}
3856
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3857
result = (int)((EST_Wave const *)arg1)->num_samples();
3858
resultobj = SWIG_From_int(static_cast< int >(result));
3859
return resultobj;
3860
fail:
3861
return NULL;
3862
}
3863
3864
3865
SWIGINTERN PyObject *_wrap_EST_Wave_num_channels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3866
PyObject *resultobj = 0;
3867
EST_Wave *arg1 = (EST_Wave *) 0 ;
3868
void *argp1 = 0 ;
3869
int res1 = 0 ;
3870
PyObject * obj0 = 0 ;
3871
int result;
3872
3873
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_num_channels",&obj0)) SWIG_fail;
3874
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3875
if (!SWIG_IsOK(res1)) {
3876
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_num_channels" "', argument " "1"" of type '" "EST_Wave const *""'");
3877
}
3878
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3879
result = (int)((EST_Wave const *)arg1)->num_channels();
3880
resultobj = SWIG_From_int(static_cast< int >(result));
3881
return resultobj;
3882
fail:
3883
return NULL;
3884
}
3885
3886
3887
SWIGINTERN PyObject *_wrap_EST_Wave_sample_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3888
PyObject *resultobj = 0;
3889
EST_Wave *arg1 = (EST_Wave *) 0 ;
3890
void *argp1 = 0 ;
3891
int res1 = 0 ;
3892
PyObject * obj0 = 0 ;
3893
int result;
3894
3895
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_sample_rate",&obj0)) SWIG_fail;
3896
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3897
if (!SWIG_IsOK(res1)) {
3898
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_sample_rate" "', argument " "1"" of type '" "EST_Wave const *""'");
3899
}
3900
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3901
result = (int)((EST_Wave const *)arg1)->sample_rate();
3902
resultobj = SWIG_From_int(static_cast< int >(result));
3903
return resultobj;
3904
fail:
3905
return NULL;
3906
}
3907
3908
3909
SWIGINTERN PyObject *_wrap_EST_Wave_set_sample_rate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3910
PyObject *resultobj = 0;
3911
EST_Wave *arg1 = (EST_Wave *) 0 ;
3912
int arg2 ;
3913
void *argp1 = 0 ;
3914
int res1 = 0 ;
3915
int val2 ;
3916
int ecode2 = 0 ;
3917
PyObject * obj0 = 0 ;
3918
PyObject * obj1 = 0 ;
3919
3920
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_set_sample_rate",&obj0,&obj1)) SWIG_fail;
3921
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3922
if (!SWIG_IsOK(res1)) {
3923
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_sample_rate" "', argument " "1"" of type '" "EST_Wave *""'");
3924
}
3925
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3926
ecode2 = SWIG_AsVal_int(obj1, &val2);
3927
if (!SWIG_IsOK(ecode2)) {
3928
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_set_sample_rate" "', argument " "2"" of type '" "int""'");
3929
}
3930
arg2 = static_cast< int >(val2);
3931
(arg1)->set_sample_rate(arg2);
3932
resultobj = SWIG_Py_Void();
3933
return resultobj;
3934
fail:
3935
return NULL;
3936
}
3937
3938
3939
SWIGINTERN PyObject *_wrap_EST_Wave_length(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3940
PyObject *resultobj = 0;
3941
EST_Wave *arg1 = (EST_Wave *) 0 ;
3942
void *argp1 = 0 ;
3943
int res1 = 0 ;
3944
PyObject * obj0 = 0 ;
3945
int result;
3946
3947
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_length",&obj0)) SWIG_fail;
3948
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3949
if (!SWIG_IsOK(res1)) {
3950
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_length" "', argument " "1"" of type '" "EST_Wave const *""'");
3951
}
3952
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3953
result = (int)((EST_Wave const *)arg1)->length();
3954
resultobj = SWIG_From_int(static_cast< int >(result));
3955
return resultobj;
3956
fail:
3957
return NULL;
3958
}
3959
3960
3961
SWIGINTERN PyObject *_wrap_EST_Wave_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3962
PyObject *resultobj = 0;
3963
EST_Wave *arg1 = (EST_Wave *) 0 ;
3964
void *argp1 = 0 ;
3965
int res1 = 0 ;
3966
PyObject * obj0 = 0 ;
3967
float result;
3968
3969
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_end",&obj0)) SWIG_fail;
3970
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3971
if (!SWIG_IsOK(res1)) {
3972
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_end" "', argument " "1"" of type '" "EST_Wave *""'");
3973
}
3974
arg1 = reinterpret_cast< EST_Wave * >(argp1);
3975
result = (float)(arg1)->end();
3976
resultobj = SWIG_From_float(static_cast< float >(result));
3977
return resultobj;
3978
fail:
3979
return NULL;
3980
}
3981
3982
3983
SWIGINTERN PyObject *_wrap_EST_Wave_have_left_context(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3984
PyObject *resultobj = 0;
3985
EST_Wave *arg1 = (EST_Wave *) 0 ;
3986
unsigned int arg2 ;
3987
void *argp1 = 0 ;
3988
int res1 = 0 ;
3989
unsigned int val2 ;
3990
int ecode2 = 0 ;
3991
PyObject * obj0 = 0 ;
3992
PyObject * obj1 = 0 ;
3993
bool result;
3994
3995
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_have_left_context",&obj0,&obj1)) SWIG_fail;
3996
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
3997
if (!SWIG_IsOK(res1)) {
3998
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_have_left_context" "', argument " "1"" of type '" "EST_Wave const *""'");
3999
}
4000
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4001
ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4002
if (!SWIG_IsOK(ecode2)) {
4003
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_have_left_context" "', argument " "2"" of type '" "unsigned int""'");
4004
}
4005
arg2 = static_cast< unsigned int >(val2);
4006
result = (bool)((EST_Wave const *)arg1)->have_left_context(arg2);
4007
resultobj = SWIG_From_bool(static_cast< bool >(result));
4008
return resultobj;
4009
fail:
4010
return NULL;
4011
}
4012
4013
4014
SWIGINTERN PyObject *_wrap_EST_Wave_sample_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4015
PyObject *resultobj = 0;
4016
EST_Wave *arg1 = (EST_Wave *) 0 ;
4017
void *argp1 = 0 ;
4018
int res1 = 0 ;
4019
PyObject * obj0 = 0 ;
4020
EST_String result;
4021
4022
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_sample_type",&obj0)) SWIG_fail;
4023
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4024
if (!SWIG_IsOK(res1)) {
4025
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_sample_type" "', argument " "1"" of type '" "EST_Wave const *""'");
4026
}
4027
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4028
result = ((EST_Wave const *)arg1)->sample_type();
4029
{
4030
int len = (&result)->length();
4031
resultobj = (len ? PyString_FromStringAndSize((&result)->str(),len) : Py_BuildValue((char*)""));
4032
4033
}
4034
return resultobj;
4035
fail:
4036
return NULL;
4037
}
4038
4039
4040
SWIGINTERN PyObject *_wrap_EST_Wave_set_sample_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4041
PyObject *resultobj = 0;
4042
EST_Wave *arg1 = (EST_Wave *) 0 ;
4043
EST_String arg2 ;
4044
void *argp1 = 0 ;
4045
int res1 = 0 ;
4046
PyObject * obj0 = 0 ;
4047
PyObject * obj1 = 0 ;
4048
4049
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_set_sample_type",&obj0,&obj1)) SWIG_fail;
4050
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4051
if (!SWIG_IsOK(res1)) {
4052
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_sample_type" "', argument " "1"" of type '" "EST_Wave *""'");
4053
}
4054
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4055
{
4056
char *str; Py_ssize_t len;
4057
PyString_AsStringAndSize(obj1, &str, &len);
4058
arg2 = EST_String( str, len, 0, len );
4059
}
4060
(arg1)->set_sample_type(arg2);
4061
resultobj = SWIG_Py_Void();
4062
return resultobj;
4063
fail:
4064
return NULL;
4065
}
4066
4067
4068
SWIGINTERN PyObject *_wrap_EST_Wave_file_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4069
PyObject *resultobj = 0;
4070
EST_Wave *arg1 = (EST_Wave *) 0 ;
4071
void *argp1 = 0 ;
4072
int res1 = 0 ;
4073
PyObject * obj0 = 0 ;
4074
EST_String result;
4075
4076
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_file_type",&obj0)) SWIG_fail;
4077
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4078
if (!SWIG_IsOK(res1)) {
4079
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_file_type" "', argument " "1"" of type '" "EST_Wave const *""'");
4080
}
4081
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4082
result = ((EST_Wave const *)arg1)->file_type();
4083
{
4084
int len = (&result)->length();
4085
resultobj = (len ? PyString_FromStringAndSize((&result)->str(),len) : Py_BuildValue((char*)""));
4086
4087
}
4088
return resultobj;
4089
fail:
4090
return NULL;
4091
}
4092
4093
4094
SWIGINTERN PyObject *_wrap_EST_Wave_set_file_type(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4095
PyObject *resultobj = 0;
4096
EST_Wave *arg1 = (EST_Wave *) 0 ;
4097
EST_String arg2 ;
4098
void *argp1 = 0 ;
4099
int res1 = 0 ;
4100
PyObject * obj0 = 0 ;
4101
PyObject * obj1 = 0 ;
4102
4103
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_set_file_type",&obj0,&obj1)) SWIG_fail;
4104
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4105
if (!SWIG_IsOK(res1)) {
4106
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_file_type" "', argument " "1"" of type '" "EST_Wave *""'");
4107
}
4108
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4109
{
4110
char *str; Py_ssize_t len;
4111
PyString_AsStringAndSize(obj1, &str, &len);
4112
arg2 = EST_String( str, len, 0, len );
4113
}
4114
(arg1)->set_file_type(arg2);
4115
resultobj = SWIG_Py_Void();
4116
return resultobj;
4117
fail:
4118
return NULL;
4119
}
4120
4121
4122
SWIGINTERN PyObject *_wrap_EST_Wave_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4123
PyObject *resultobj = 0;
4124
EST_Wave *arg1 = (EST_Wave *) 0 ;
4125
void *argp1 = 0 ;
4126
int res1 = 0 ;
4127
PyObject * obj0 = 0 ;
4128
EST_String result;
4129
4130
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_name",&obj0)) SWIG_fail;
4131
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4132
if (!SWIG_IsOK(res1)) {
4133
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_name" "', argument " "1"" of type '" "EST_Wave const *""'");
4134
}
4135
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4136
result = ((EST_Wave const *)arg1)->name();
4137
{
4138
int len = (&result)->length();
4139
resultobj = (len ? PyString_FromStringAndSize((&result)->str(),len) : Py_BuildValue((char*)""));
4140
4141
}
4142
return resultobj;
4143
fail:
4144
return NULL;
4145
}
4146
4147
4148
SWIGINTERN PyObject *_wrap_EST_Wave_set_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4149
PyObject *resultobj = 0;
4150
EST_Wave *arg1 = (EST_Wave *) 0 ;
4151
EST_String arg2 ;
4152
void *argp1 = 0 ;
4153
int res1 = 0 ;
4154
PyObject * obj0 = 0 ;
4155
PyObject * obj1 = 0 ;
4156
4157
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_set_name",&obj0,&obj1)) SWIG_fail;
4158
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4159
if (!SWIG_IsOK(res1)) {
4160
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_set_name" "', argument " "1"" of type '" "EST_Wave *""'");
4161
}
4162
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4163
{
4164
char *str; Py_ssize_t len;
4165
PyString_AsStringAndSize(obj1, &str, &len);
4166
arg2 = EST_String( str, len, 0, len );
4167
}
4168
(arg1)->set_name(arg2);
4169
resultobj = SWIG_Py_Void();
4170
return resultobj;
4171
fail:
4172
return NULL;
4173
}
4174
4175
4176
SWIGINTERN PyObject *_wrap_EST_Wave_resize__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4177
PyObject *resultobj = 0;
4178
EST_Wave *arg1 = (EST_Wave *) 0 ;
4179
int arg2 ;
4180
int arg3 ;
4181
int arg4 ;
4182
void *argp1 = 0 ;
4183
int res1 = 0 ;
4184
int val2 ;
4185
int ecode2 = 0 ;
4186
int val3 ;
4187
int ecode3 = 0 ;
4188
int val4 ;
4189
int ecode4 = 0 ;
4190
PyObject * obj0 = 0 ;
4191
PyObject * obj1 = 0 ;
4192
PyObject * obj2 = 0 ;
4193
PyObject * obj3 = 0 ;
4194
4195
if (!PyArg_ParseTuple(args,(char *)"OOOO:EST_Wave_resize",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4196
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4197
if (!SWIG_IsOK(res1)) {
4198
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_resize" "', argument " "1"" of type '" "EST_Wave *""'");
4199
}
4200
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4201
ecode2 = SWIG_AsVal_int(obj1, &val2);
4202
if (!SWIG_IsOK(ecode2)) {
4203
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_resize" "', argument " "2"" of type '" "int""'");
4204
}
4205
arg2 = static_cast< int >(val2);
4206
ecode3 = SWIG_AsVal_int(obj2, &val3);
4207
if (!SWIG_IsOK(ecode3)) {
4208
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_resize" "', argument " "3"" of type '" "int""'");
4209
}
4210
arg3 = static_cast< int >(val3);
4211
ecode4 = SWIG_AsVal_int(obj3, &val4);
4212
if (!SWIG_IsOK(ecode4)) {
4213
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_resize" "', argument " "4"" of type '" "int""'");
4214
}
4215
arg4 = static_cast< int >(val4);
4216
(arg1)->resize(arg2,arg3,arg4);
4217
resultobj = SWIG_Py_Void();
4218
return resultobj;
4219
fail:
4220
return NULL;
4221
}
4222
4223
4224
SWIGINTERN PyObject *_wrap_EST_Wave_resize__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4225
PyObject *resultobj = 0;
4226
EST_Wave *arg1 = (EST_Wave *) 0 ;
4227
int arg2 ;
4228
int arg3 ;
4229
void *argp1 = 0 ;
4230
int res1 = 0 ;
4231
int val2 ;
4232
int ecode2 = 0 ;
4233
int val3 ;
4234
int ecode3 = 0 ;
4235
PyObject * obj0 = 0 ;
4236
PyObject * obj1 = 0 ;
4237
PyObject * obj2 = 0 ;
4238
4239
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_resize",&obj0,&obj1,&obj2)) SWIG_fail;
4240
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4241
if (!SWIG_IsOK(res1)) {
4242
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_resize" "', argument " "1"" of type '" "EST_Wave *""'");
4243
}
4244
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4245
ecode2 = SWIG_AsVal_int(obj1, &val2);
4246
if (!SWIG_IsOK(ecode2)) {
4247
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_resize" "', argument " "2"" of type '" "int""'");
4248
}
4249
arg2 = static_cast< int >(val2);
4250
ecode3 = SWIG_AsVal_int(obj2, &val3);
4251
if (!SWIG_IsOK(ecode3)) {
4252
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_resize" "', argument " "3"" of type '" "int""'");
4253
}
4254
arg3 = static_cast< int >(val3);
4255
(arg1)->resize(arg2,arg3);
4256
resultobj = SWIG_Py_Void();
4257
return resultobj;
4258
fail:
4259
return NULL;
4260
}
4261
4262
4263
SWIGINTERN PyObject *_wrap_EST_Wave_resize__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4264
PyObject *resultobj = 0;
4265
EST_Wave *arg1 = (EST_Wave *) 0 ;
4266
int arg2 ;
4267
void *argp1 = 0 ;
4268
int res1 = 0 ;
4269
int val2 ;
4270
int ecode2 = 0 ;
4271
PyObject * obj0 = 0 ;
4272
PyObject * obj1 = 0 ;
4273
4274
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_resize",&obj0,&obj1)) SWIG_fail;
4275
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4276
if (!SWIG_IsOK(res1)) {
4277
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_resize" "', argument " "1"" of type '" "EST_Wave *""'");
4278
}
4279
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4280
ecode2 = SWIG_AsVal_int(obj1, &val2);
4281
if (!SWIG_IsOK(ecode2)) {
4282
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_resize" "', argument " "2"" of type '" "int""'");
4283
}
4284
arg2 = static_cast< int >(val2);
4285
(arg1)->resize(arg2);
4286
resultobj = SWIG_Py_Void();
4287
return resultobj;
4288
fail:
4289
return NULL;
4290
}
4291
4292
4293
SWIGINTERN PyObject *_wrap_EST_Wave_resize(PyObject *self, PyObject *args) {
4294
int argc;
4295
PyObject *argv[5];
4296
int ii;
4297
4298
if (!PyTuple_Check(args)) SWIG_fail;
4299
argc = (int)PyObject_Length(args);
4300
for (ii = 0; (ii < argc) && (ii < 4); ii++) {
4301
argv[ii] = PyTuple_GET_ITEM(args,ii);
4302
}
4303
if (argc == 2) {
4304
int _v;
4305
void *vptr = 0;
4306
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4307
_v = SWIG_CheckState(res);
4308
if (_v) {
4309
{
4310
int res = SWIG_AsVal_int(argv[1], NULL);
4311
_v = SWIG_CheckState(res);
4312
}
4313
if (_v) {
4314
return _wrap_EST_Wave_resize__SWIG_2(self, args);
4315
}
4316
}
4317
}
4318
if (argc == 3) {
4319
int _v;
4320
void *vptr = 0;
4321
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4322
_v = SWIG_CheckState(res);
4323
if (_v) {
4324
{
4325
int res = SWIG_AsVal_int(argv[1], NULL);
4326
_v = SWIG_CheckState(res);
4327
}
4328
if (_v) {
4329
{
4330
int res = SWIG_AsVal_int(argv[2], NULL);
4331
_v = SWIG_CheckState(res);
4332
}
4333
if (_v) {
4334
return _wrap_EST_Wave_resize__SWIG_1(self, args);
4335
}
4336
}
4337
}
4338
}
4339
if (argc == 4) {
4340
int _v;
4341
void *vptr = 0;
4342
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4343
_v = SWIG_CheckState(res);
4344
if (_v) {
4345
{
4346
int res = SWIG_AsVal_int(argv[1], NULL);
4347
_v = SWIG_CheckState(res);
4348
}
4349
if (_v) {
4350
{
4351
int res = SWIG_AsVal_int(argv[2], NULL);
4352
_v = SWIG_CheckState(res);
4353
}
4354
if (_v) {
4355
{
4356
int res = SWIG_AsVal_int(argv[3], NULL);
4357
_v = SWIG_CheckState(res);
4358
}
4359
if (_v) {
4360
return _wrap_EST_Wave_resize__SWIG_0(self, args);
4361
}
4362
}
4363
}
4364
}
4365
}
4366
4367
fail:
4368
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_resize'.\n"
4369
" Possible C/C++ prototypes are:\n"
4370
" resize(EST_Wave *,int,int,int)\n"
4371
" resize(EST_Wave *,int,int)\n"
4372
" resize(EST_Wave *,int)\n");
4373
return NULL;
4374
}
4375
4376
4377
SWIGINTERN PyObject *_wrap_EST_Wave_resample(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4378
PyObject *resultobj = 0;
4379
EST_Wave *arg1 = (EST_Wave *) 0 ;
4380
int arg2 ;
4381
void *argp1 = 0 ;
4382
int res1 = 0 ;
4383
int val2 ;
4384
int ecode2 = 0 ;
4385
PyObject * obj0 = 0 ;
4386
PyObject * obj1 = 0 ;
4387
4388
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_resample",&obj0,&obj1)) SWIG_fail;
4389
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4390
if (!SWIG_IsOK(res1)) {
4391
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_resample" "', argument " "1"" of type '" "EST_Wave *""'");
4392
}
4393
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4394
ecode2 = SWIG_AsVal_int(obj1, &val2);
4395
if (!SWIG_IsOK(ecode2)) {
4396
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_resample" "', argument " "2"" of type '" "int""'");
4397
}
4398
arg2 = static_cast< int >(val2);
4399
(arg1)->resample(arg2);
4400
resultobj = SWIG_Py_Void();
4401
return resultobj;
4402
fail:
4403
return NULL;
4404
}
4405
4406
4407
SWIGINTERN PyObject *_wrap_EST_Wave_rescale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4408
PyObject *resultobj = 0;
4409
EST_Wave *arg1 = (EST_Wave *) 0 ;
4410
float arg2 ;
4411
int arg3 ;
4412
void *argp1 = 0 ;
4413
int res1 = 0 ;
4414
float val2 ;
4415
int ecode2 = 0 ;
4416
int val3 ;
4417
int ecode3 = 0 ;
4418
PyObject * obj0 = 0 ;
4419
PyObject * obj1 = 0 ;
4420
PyObject * obj2 = 0 ;
4421
4422
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_rescale",&obj0,&obj1,&obj2)) SWIG_fail;
4423
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4424
if (!SWIG_IsOK(res1)) {
4425
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_rescale" "', argument " "1"" of type '" "EST_Wave *""'");
4426
}
4427
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4428
ecode2 = SWIG_AsVal_float(obj1, &val2);
4429
if (!SWIG_IsOK(ecode2)) {
4430
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_rescale" "', argument " "2"" of type '" "float""'");
4431
}
4432
arg2 = static_cast< float >(val2);
4433
ecode3 = SWIG_AsVal_int(obj2, &val3);
4434
if (!SWIG_IsOK(ecode3)) {
4435
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_rescale" "', argument " "3"" of type '" "int""'");
4436
}
4437
arg3 = static_cast< int >(val3);
4438
(arg1)->rescale(arg2,arg3);
4439
resultobj = SWIG_Py_Void();
4440
return resultobj;
4441
fail:
4442
return NULL;
4443
}
4444
4445
4446
SWIGINTERN PyObject *_wrap_EST_Wave_rescale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4447
PyObject *resultobj = 0;
4448
EST_Wave *arg1 = (EST_Wave *) 0 ;
4449
float arg2 ;
4450
void *argp1 = 0 ;
4451
int res1 = 0 ;
4452
float val2 ;
4453
int ecode2 = 0 ;
4454
PyObject * obj0 = 0 ;
4455
PyObject * obj1 = 0 ;
4456
4457
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_rescale",&obj0,&obj1)) SWIG_fail;
4458
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4459
if (!SWIG_IsOK(res1)) {
4460
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_rescale" "', argument " "1"" of type '" "EST_Wave *""'");
4461
}
4462
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4463
ecode2 = SWIG_AsVal_float(obj1, &val2);
4464
if (!SWIG_IsOK(ecode2)) {
4465
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_rescale" "', argument " "2"" of type '" "float""'");
4466
}
4467
arg2 = static_cast< float >(val2);
4468
(arg1)->rescale(arg2);
4469
resultobj = SWIG_Py_Void();
4470
return resultobj;
4471
fail:
4472
return NULL;
4473
}
4474
4475
4476
SWIGINTERN PyObject *_wrap_EST_Wave_rescale__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477
PyObject *resultobj = 0;
4478
EST_Wave *arg1 = (EST_Wave *) 0 ;
4479
EST_Track *arg2 = 0 ;
4480
void *argp1 = 0 ;
4481
int res1 = 0 ;
4482
void *argp2 = 0 ;
4483
int res2 = 0 ;
4484
PyObject * obj0 = 0 ;
4485
PyObject * obj1 = 0 ;
4486
4487
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_rescale",&obj0,&obj1)) SWIG_fail;
4488
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4489
if (!SWIG_IsOK(res1)) {
4490
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_rescale" "', argument " "1"" of type '" "EST_Wave *""'");
4491
}
4492
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4493
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Track, 0 | 0);
4494
if (!SWIG_IsOK(res2)) {
4495
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EST_Wave_rescale" "', argument " "2"" of type '" "EST_Track const &""'");
4496
}
4497
if (!argp2) {
4498
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EST_Wave_rescale" "', argument " "2"" of type '" "EST_Track const &""'");
4499
}
4500
arg2 = reinterpret_cast< EST_Track * >(argp2);
4501
(arg1)->rescale((EST_Track const &)*arg2);
4502
resultobj = SWIG_Py_Void();
4503
return resultobj;
4504
fail:
4505
return NULL;
4506
}
4507
4508
4509
SWIGINTERN PyObject *_wrap_EST_Wave_rescale(PyObject *self, PyObject *args) {
4510
int argc;
4511
PyObject *argv[4];
4512
int ii;
4513
4514
if (!PyTuple_Check(args)) SWIG_fail;
4515
argc = (int)PyObject_Length(args);
4516
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4517
argv[ii] = PyTuple_GET_ITEM(args,ii);
4518
}
4519
if (argc == 2) {
4520
int _v;
4521
void *vptr = 0;
4522
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4523
_v = SWIG_CheckState(res);
4524
if (_v) {
4525
int res = SWIG_ConvertPtr(argv[1], 0, SWIGTYPE_p_EST_Track, 0);
4526
_v = SWIG_CheckState(res);
4527
if (_v) {
4528
return _wrap_EST_Wave_rescale__SWIG_2(self, args);
4529
}
4530
}
4531
}
4532
if (argc == 2) {
4533
int _v;
4534
void *vptr = 0;
4535
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4536
_v = SWIG_CheckState(res);
4537
if (_v) {
4538
{
4539
int res = SWIG_AsVal_float(argv[1], NULL);
4540
_v = SWIG_CheckState(res);
4541
}
4542
if (_v) {
4543
return _wrap_EST_Wave_rescale__SWIG_1(self, args);
4544
}
4545
}
4546
}
4547
if (argc == 3) {
4548
int _v;
4549
void *vptr = 0;
4550
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4551
_v = SWIG_CheckState(res);
4552
if (_v) {
4553
{
4554
int res = SWIG_AsVal_float(argv[1], NULL);
4555
_v = SWIG_CheckState(res);
4556
}
4557
if (_v) {
4558
{
4559
int res = SWIG_AsVal_int(argv[2], NULL);
4560
_v = SWIG_CheckState(res);
4561
}
4562
if (_v) {
4563
return _wrap_EST_Wave_rescale__SWIG_0(self, args);
4564
}
4565
}
4566
}
4567
}
4568
4569
fail:
4570
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_rescale'.\n"
4571
" Possible C/C++ prototypes are:\n"
4572
" rescale(EST_Wave *,float,int)\n"
4573
" rescale(EST_Wave *,float)\n"
4574
" rescale(EST_Wave *,EST_Track const &)\n");
4575
return NULL;
4576
}
4577
4578
4579
SWIGINTERN PyObject *_wrap_EST_Wave_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4580
PyObject *resultobj = 0;
4581
EST_Wave *arg1 = (EST_Wave *) 0 ;
4582
void *argp1 = 0 ;
4583
int res1 = 0 ;
4584
PyObject * obj0 = 0 ;
4585
4586
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_clear",&obj0)) SWIG_fail;
4587
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4588
if (!SWIG_IsOK(res1)) {
4589
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_clear" "', argument " "1"" of type '" "EST_Wave *""'");
4590
}
4591
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4592
(arg1)->clear();
4593
resultobj = SWIG_Py_Void();
4594
return resultobj;
4595
fail:
4596
return NULL;
4597
}
4598
4599
4600
SWIGINTERN PyObject *_wrap_EST_Wave_copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4601
PyObject *resultobj = 0;
4602
EST_Wave *arg1 = (EST_Wave *) 0 ;
4603
EST_Wave *arg2 = 0 ;
4604
void *argp1 = 0 ;
4605
int res1 = 0 ;
4606
void *argp2 = 0 ;
4607
int res2 = 0 ;
4608
PyObject * obj0 = 0 ;
4609
PyObject * obj1 = 0 ;
4610
4611
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_copy",&obj0,&obj1)) SWIG_fail;
4612
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4613
if (!SWIG_IsOK(res1)) {
4614
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_copy" "', argument " "1"" of type '" "EST_Wave *""'");
4615
}
4616
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4617
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 | 0);
4618
if (!SWIG_IsOK(res2)) {
4619
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EST_Wave_copy" "', argument " "2"" of type '" "EST_Wave const &""'");
4620
}
4621
if (!argp2) {
4622
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EST_Wave_copy" "', argument " "2"" of type '" "EST_Wave const &""'");
4623
}
4624
arg2 = reinterpret_cast< EST_Wave * >(argp2);
4625
(arg1)->copy((EST_Wave const &)*arg2);
4626
resultobj = SWIG_Py_Void();
4627
return resultobj;
4628
fail:
4629
return NULL;
4630
}
4631
4632
4633
SWIGINTERN PyObject *_wrap_EST_Wave_fill__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4634
PyObject *resultobj = 0;
4635
EST_Wave *arg1 = (EST_Wave *) 0 ;
4636
short arg2 ;
4637
int arg3 ;
4638
void *argp1 = 0 ;
4639
int res1 = 0 ;
4640
short val2 ;
4641
int ecode2 = 0 ;
4642
int val3 ;
4643
int ecode3 = 0 ;
4644
PyObject * obj0 = 0 ;
4645
PyObject * obj1 = 0 ;
4646
PyObject * obj2 = 0 ;
4647
4648
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_fill",&obj0,&obj1,&obj2)) SWIG_fail;
4649
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4650
if (!SWIG_IsOK(res1)) {
4651
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_fill" "', argument " "1"" of type '" "EST_Wave *""'");
4652
}
4653
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4654
ecode2 = SWIG_AsVal_short(obj1, &val2);
4655
if (!SWIG_IsOK(ecode2)) {
4656
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_fill" "', argument " "2"" of type '" "short""'");
4657
}
4658
arg2 = static_cast< short >(val2);
4659
ecode3 = SWIG_AsVal_int(obj2, &val3);
4660
if (!SWIG_IsOK(ecode3)) {
4661
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_fill" "', argument " "3"" of type '" "int""'");
4662
}
4663
arg3 = static_cast< int >(val3);
4664
(arg1)->fill(arg2,arg3);
4665
resultobj = SWIG_Py_Void();
4666
return resultobj;
4667
fail:
4668
return NULL;
4669
}
4670
4671
4672
SWIGINTERN PyObject *_wrap_EST_Wave_fill__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4673
PyObject *resultobj = 0;
4674
EST_Wave *arg1 = (EST_Wave *) 0 ;
4675
short arg2 ;
4676
void *argp1 = 0 ;
4677
int res1 = 0 ;
4678
short val2 ;
4679
int ecode2 = 0 ;
4680
PyObject * obj0 = 0 ;
4681
PyObject * obj1 = 0 ;
4682
4683
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_fill",&obj0,&obj1)) SWIG_fail;
4684
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4685
if (!SWIG_IsOK(res1)) {
4686
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_fill" "', argument " "1"" of type '" "EST_Wave *""'");
4687
}
4688
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4689
ecode2 = SWIG_AsVal_short(obj1, &val2);
4690
if (!SWIG_IsOK(ecode2)) {
4691
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_fill" "', argument " "2"" of type '" "short""'");
4692
}
4693
arg2 = static_cast< short >(val2);
4694
(arg1)->fill(arg2);
4695
resultobj = SWIG_Py_Void();
4696
return resultobj;
4697
fail:
4698
return NULL;
4699
}
4700
4701
4702
SWIGINTERN PyObject *_wrap_EST_Wave_fill__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4703
PyObject *resultobj = 0;
4704
EST_Wave *arg1 = (EST_Wave *) 0 ;
4705
void *argp1 = 0 ;
4706
int res1 = 0 ;
4707
PyObject * obj0 = 0 ;
4708
4709
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_fill",&obj0)) SWIG_fail;
4710
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4711
if (!SWIG_IsOK(res1)) {
4712
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_fill" "', argument " "1"" of type '" "EST_Wave *""'");
4713
}
4714
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4715
(arg1)->fill();
4716
resultobj = SWIG_Py_Void();
4717
return resultobj;
4718
fail:
4719
return NULL;
4720
}
4721
4722
4723
SWIGINTERN PyObject *_wrap_EST_Wave_fill(PyObject *self, PyObject *args) {
4724
int argc;
4725
PyObject *argv[4];
4726
int ii;
4727
4728
if (!PyTuple_Check(args)) SWIG_fail;
4729
argc = (int)PyObject_Length(args);
4730
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
4731
argv[ii] = PyTuple_GET_ITEM(args,ii);
4732
}
4733
if (argc == 1) {
4734
int _v;
4735
void *vptr = 0;
4736
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4737
_v = SWIG_CheckState(res);
4738
if (_v) {
4739
return _wrap_EST_Wave_fill__SWIG_2(self, args);
4740
}
4741
}
4742
if (argc == 2) {
4743
int _v;
4744
void *vptr = 0;
4745
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4746
_v = SWIG_CheckState(res);
4747
if (_v) {
4748
{
4749
int res = SWIG_AsVal_short(argv[1], NULL);
4750
_v = SWIG_CheckState(res);
4751
}
4752
if (_v) {
4753
return _wrap_EST_Wave_fill__SWIG_1(self, args);
4754
}
4755
}
4756
}
4757
if (argc == 3) {
4758
int _v;
4759
void *vptr = 0;
4760
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4761
_v = SWIG_CheckState(res);
4762
if (_v) {
4763
{
4764
int res = SWIG_AsVal_short(argv[1], NULL);
4765
_v = SWIG_CheckState(res);
4766
}
4767
if (_v) {
4768
{
4769
int res = SWIG_AsVal_int(argv[2], NULL);
4770
_v = SWIG_CheckState(res);
4771
}
4772
if (_v) {
4773
return _wrap_EST_Wave_fill__SWIG_0(self, args);
4774
}
4775
}
4776
}
4777
}
4778
4779
fail:
4780
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_fill'.\n"
4781
" Possible C/C++ prototypes are:\n"
4782
" fill(EST_Wave *,short,int)\n"
4783
" fill(EST_Wave *,short)\n"
4784
" fill(EST_Wave *)\n");
4785
return NULL;
4786
}
4787
4788
4789
SWIGINTERN PyObject *_wrap_EST_Wave_empty__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4790
PyObject *resultobj = 0;
4791
EST_Wave *arg1 = (EST_Wave *) 0 ;
4792
int arg2 ;
4793
void *argp1 = 0 ;
4794
int res1 = 0 ;
4795
int val2 ;
4796
int ecode2 = 0 ;
4797
PyObject * obj0 = 0 ;
4798
PyObject * obj1 = 0 ;
4799
4800
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_empty",&obj0,&obj1)) SWIG_fail;
4801
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4802
if (!SWIG_IsOK(res1)) {
4803
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_empty" "', argument " "1"" of type '" "EST_Wave *""'");
4804
}
4805
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4806
ecode2 = SWIG_AsVal_int(obj1, &val2);
4807
if (!SWIG_IsOK(ecode2)) {
4808
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EST_Wave_empty" "', argument " "2"" of type '" "int""'");
4809
}
4810
arg2 = static_cast< int >(val2);
4811
(arg1)->empty(arg2);
4812
resultobj = SWIG_Py_Void();
4813
return resultobj;
4814
fail:
4815
return NULL;
4816
}
4817
4818
4819
SWIGINTERN PyObject *_wrap_EST_Wave_empty__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4820
PyObject *resultobj = 0;
4821
EST_Wave *arg1 = (EST_Wave *) 0 ;
4822
void *argp1 = 0 ;
4823
int res1 = 0 ;
4824
PyObject * obj0 = 0 ;
4825
4826
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_empty",&obj0)) SWIG_fail;
4827
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4828
if (!SWIG_IsOK(res1)) {
4829
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_empty" "', argument " "1"" of type '" "EST_Wave *""'");
4830
}
4831
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4832
(arg1)->empty();
4833
resultobj = SWIG_Py_Void();
4834
return resultobj;
4835
fail:
4836
return NULL;
4837
}
4838
4839
4840
SWIGINTERN PyObject *_wrap_EST_Wave_empty(PyObject *self, PyObject *args) {
4841
int argc;
4842
PyObject *argv[3];
4843
int ii;
4844
4845
if (!PyTuple_Check(args)) SWIG_fail;
4846
argc = (int)PyObject_Length(args);
4847
for (ii = 0; (ii < argc) && (ii < 2); ii++) {
4848
argv[ii] = PyTuple_GET_ITEM(args,ii);
4849
}
4850
if (argc == 1) {
4851
int _v;
4852
void *vptr = 0;
4853
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4854
_v = SWIG_CheckState(res);
4855
if (_v) {
4856
return _wrap_EST_Wave_empty__SWIG_1(self, args);
4857
}
4858
}
4859
if (argc == 2) {
4860
int _v;
4861
void *vptr = 0;
4862
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
4863
_v = SWIG_CheckState(res);
4864
if (_v) {
4865
{
4866
int res = SWIG_AsVal_int(argv[1], NULL);
4867
_v = SWIG_CheckState(res);
4868
}
4869
if (_v) {
4870
return _wrap_EST_Wave_empty__SWIG_0(self, args);
4871
}
4872
}
4873
}
4874
4875
fail:
4876
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_empty'.\n"
4877
" Possible C/C++ prototypes are:\n"
4878
" empty(EST_Wave *,int)\n"
4879
" empty(EST_Wave *)\n");
4880
return NULL;
4881
}
4882
4883
4884
SWIGINTERN PyObject *_wrap_EST_Wave_load__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4885
PyObject *resultobj = 0;
4886
EST_Wave *arg1 = (EST_Wave *) 0 ;
4887
EST_String arg2 ;
4888
int arg3 ;
4889
int arg4 ;
4890
int arg5 ;
4891
void *argp1 = 0 ;
4892
int res1 = 0 ;
4893
int val3 ;
4894
int ecode3 = 0 ;
4895
int val4 ;
4896
int ecode4 = 0 ;
4897
int val5 ;
4898
int ecode5 = 0 ;
4899
PyObject * obj0 = 0 ;
4900
PyObject * obj1 = 0 ;
4901
PyObject * obj2 = 0 ;
4902
PyObject * obj3 = 0 ;
4903
PyObject * obj4 = 0 ;
4904
EST_read_status result;
4905
4906
if (!PyArg_ParseTuple(args,(char *)"OOOOO:EST_Wave_load",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
4907
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4908
if (!SWIG_IsOK(res1)) {
4909
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load" "', argument " "1"" of type '" "EST_Wave *""'");
4910
}
4911
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4912
{
4913
char *str; Py_ssize_t len;
4914
PyString_AsStringAndSize(obj1, &str, &len);
4915
arg2 = EST_String( str, len, 0, len );
4916
}
4917
ecode3 = SWIG_AsVal_int(obj2, &val3);
4918
if (!SWIG_IsOK(ecode3)) {
4919
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_load" "', argument " "3"" of type '" "int""'");
4920
}
4921
arg3 = static_cast< int >(val3);
4922
ecode4 = SWIG_AsVal_int(obj3, &val4);
4923
if (!SWIG_IsOK(ecode4)) {
4924
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_load" "', argument " "4"" of type '" "int""'");
4925
}
4926
arg4 = static_cast< int >(val4);
4927
ecode5 = SWIG_AsVal_int(obj4, &val5);
4928
if (!SWIG_IsOK(ecode5)) {
4929
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "EST_Wave_load" "', argument " "5"" of type '" "int""'");
4930
}
4931
arg5 = static_cast< int >(val5);
4932
result = (EST_read_status)(arg1)->load(arg2,arg3,arg4,arg5);
4933
resultobj = SWIG_From_int(static_cast< int >(result));
4934
return resultobj;
4935
fail:
4936
return NULL;
4937
}
4938
4939
4940
SWIGINTERN PyObject *_wrap_EST_Wave_load__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4941
PyObject *resultobj = 0;
4942
EST_Wave *arg1 = (EST_Wave *) 0 ;
4943
EST_String arg2 ;
4944
int arg3 ;
4945
int arg4 ;
4946
void *argp1 = 0 ;
4947
int res1 = 0 ;
4948
int val3 ;
4949
int ecode3 = 0 ;
4950
int val4 ;
4951
int ecode4 = 0 ;
4952
PyObject * obj0 = 0 ;
4953
PyObject * obj1 = 0 ;
4954
PyObject * obj2 = 0 ;
4955
PyObject * obj3 = 0 ;
4956
EST_read_status result;
4957
4958
if (!PyArg_ParseTuple(args,(char *)"OOOO:EST_Wave_load",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
4959
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
4960
if (!SWIG_IsOK(res1)) {
4961
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load" "', argument " "1"" of type '" "EST_Wave *""'");
4962
}
4963
arg1 = reinterpret_cast< EST_Wave * >(argp1);
4964
{
4965
char *str; Py_ssize_t len;
4966
PyString_AsStringAndSize(obj1, &str, &len);
4967
arg2 = EST_String( str, len, 0, len );
4968
}
4969
ecode3 = SWIG_AsVal_int(obj2, &val3);
4970
if (!SWIG_IsOK(ecode3)) {
4971
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_load" "', argument " "3"" of type '" "int""'");
4972
}
4973
arg3 = static_cast< int >(val3);
4974
ecode4 = SWIG_AsVal_int(obj3, &val4);
4975
if (!SWIG_IsOK(ecode4)) {
4976
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_load" "', argument " "4"" of type '" "int""'");
4977
}
4978
arg4 = static_cast< int >(val4);
4979
result = (EST_read_status)(arg1)->load(arg2,arg3,arg4);
4980
resultobj = SWIG_From_int(static_cast< int >(result));
4981
return resultobj;
4982
fail:
4983
return NULL;
4984
}
4985
4986
4987
SWIGINTERN PyObject *_wrap_EST_Wave_load__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4988
PyObject *resultobj = 0;
4989
EST_Wave *arg1 = (EST_Wave *) 0 ;
4990
EST_String arg2 ;
4991
int arg3 ;
4992
void *argp1 = 0 ;
4993
int res1 = 0 ;
4994
int val3 ;
4995
int ecode3 = 0 ;
4996
PyObject * obj0 = 0 ;
4997
PyObject * obj1 = 0 ;
4998
PyObject * obj2 = 0 ;
4999
EST_read_status result;
5000
5001
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_load",&obj0,&obj1,&obj2)) SWIG_fail;
5002
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5003
if (!SWIG_IsOK(res1)) {
5004
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load" "', argument " "1"" of type '" "EST_Wave *""'");
5005
}
5006
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5007
{
5008
char *str; Py_ssize_t len;
5009
PyString_AsStringAndSize(obj1, &str, &len);
5010
arg2 = EST_String( str, len, 0, len );
5011
}
5012
ecode3 = SWIG_AsVal_int(obj2, &val3);
5013
if (!SWIG_IsOK(ecode3)) {
5014
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EST_Wave_load" "', argument " "3"" of type '" "int""'");
5015
}
5016
arg3 = static_cast< int >(val3);
5017
result = (EST_read_status)(arg1)->load(arg2,arg3);
5018
resultobj = SWIG_From_int(static_cast< int >(result));
5019
return resultobj;
5020
fail:
5021
return NULL;
5022
}
5023
5024
5025
SWIGINTERN PyObject *_wrap_EST_Wave_load__SWIG_3(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5026
PyObject *resultobj = 0;
5027
EST_Wave *arg1 = (EST_Wave *) 0 ;
5028
EST_String arg2 ;
5029
void *argp1 = 0 ;
5030
int res1 = 0 ;
5031
PyObject * obj0 = 0 ;
5032
PyObject * obj1 = 0 ;
5033
EST_read_status result;
5034
5035
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_load",&obj0,&obj1)) SWIG_fail;
5036
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5037
if (!SWIG_IsOK(res1)) {
5038
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load" "', argument " "1"" of type '" "EST_Wave *""'");
5039
}
5040
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5041
{
5042
char *str; Py_ssize_t len;
5043
PyString_AsStringAndSize(obj1, &str, &len);
5044
arg2 = EST_String( str, len, 0, len );
5045
}
5046
result = (EST_read_status)(arg1)->load(arg2);
5047
resultobj = SWIG_From_int(static_cast< int >(result));
5048
return resultobj;
5049
fail:
5050
return NULL;
5051
}
5052
5053
5054
SWIGINTERN PyObject *_wrap_EST_Wave_load(PyObject *self, PyObject *args) {
5055
int argc;
5056
PyObject *argv[6];
5057
int ii;
5058
5059
if (!PyTuple_Check(args)) SWIG_fail;
5060
argc = (int)PyObject_Length(args);
5061
for (ii = 0; (ii < argc) && (ii < 5); ii++) {
5062
argv[ii] = PyTuple_GET_ITEM(args,ii);
5063
}
5064
if (argc == 2) {
5065
int _v;
5066
void *vptr = 0;
5067
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5068
_v = SWIG_CheckState(res);
5069
if (_v) {
5070
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5071
_v = SWIG_CheckState(res);
5072
if (_v) {
5073
return _wrap_EST_Wave_load__SWIG_3(self, args);
5074
}
5075
}
5076
}
5077
if (argc == 3) {
5078
int _v;
5079
void *vptr = 0;
5080
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5081
_v = SWIG_CheckState(res);
5082
if (_v) {
5083
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5084
_v = SWIG_CheckState(res);
5085
if (_v) {
5086
{
5087
int res = SWIG_AsVal_int(argv[2], NULL);
5088
_v = SWIG_CheckState(res);
5089
}
5090
if (_v) {
5091
return _wrap_EST_Wave_load__SWIG_2(self, args);
5092
}
5093
}
5094
}
5095
}
5096
if (argc == 4) {
5097
int _v;
5098
void *vptr = 0;
5099
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5100
_v = SWIG_CheckState(res);
5101
if (_v) {
5102
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5103
_v = SWIG_CheckState(res);
5104
if (_v) {
5105
{
5106
int res = SWIG_AsVal_int(argv[2], NULL);
5107
_v = SWIG_CheckState(res);
5108
}
5109
if (_v) {
5110
{
5111
int res = SWIG_AsVal_int(argv[3], NULL);
5112
_v = SWIG_CheckState(res);
5113
}
5114
if (_v) {
5115
return _wrap_EST_Wave_load__SWIG_1(self, args);
5116
}
5117
}
5118
}
5119
}
5120
}
5121
if (argc == 5) {
5122
int _v;
5123
void *vptr = 0;
5124
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5125
_v = SWIG_CheckState(res);
5126
if (_v) {
5127
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5128
_v = SWIG_CheckState(res);
5129
if (_v) {
5130
{
5131
int res = SWIG_AsVal_int(argv[2], NULL);
5132
_v = SWIG_CheckState(res);
5133
}
5134
if (_v) {
5135
{
5136
int res = SWIG_AsVal_int(argv[3], NULL);
5137
_v = SWIG_CheckState(res);
5138
}
5139
if (_v) {
5140
{
5141
int res = SWIG_AsVal_int(argv[4], NULL);
5142
_v = SWIG_CheckState(res);
5143
}
5144
if (_v) {
5145
return _wrap_EST_Wave_load__SWIG_0(self, args);
5146
}
5147
}
5148
}
5149
}
5150
}
5151
}
5152
5153
fail:
5154
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_load'.\n"
5155
" Possible C/C++ prototypes are:\n"
5156
" load(EST_Wave *,EST_String const,int,int,int)\n"
5157
" load(EST_Wave *,EST_String const,int,int)\n"
5158
" load(EST_Wave *,EST_String const,int)\n"
5159
" load(EST_Wave *,EST_String const)\n");
5160
return NULL;
5161
}
5162
5163
5164
SWIGINTERN PyObject *_wrap_EST_Wave_load_file__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5165
PyObject *resultobj = 0;
5166
EST_Wave *arg1 = (EST_Wave *) 0 ;
5167
EST_String arg2 ;
5168
EST_String arg3 ;
5169
int arg4 ;
5170
EST_String arg5 ;
5171
int arg6 ;
5172
int arg7 ;
5173
int arg8 ;
5174
int arg9 ;
5175
void *argp1 = 0 ;
5176
int res1 = 0 ;
5177
int val4 ;
5178
int ecode4 = 0 ;
5179
int val6 ;
5180
int ecode6 = 0 ;
5181
int val7 ;
5182
int ecode7 = 0 ;
5183
int val8 ;
5184
int ecode8 = 0 ;
5185
int val9 ;
5186
int ecode9 = 0 ;
5187
PyObject * obj0 = 0 ;
5188
PyObject * obj1 = 0 ;
5189
PyObject * obj2 = 0 ;
5190
PyObject * obj3 = 0 ;
5191
PyObject * obj4 = 0 ;
5192
PyObject * obj5 = 0 ;
5193
PyObject * obj6 = 0 ;
5194
PyObject * obj7 = 0 ;
5195
PyObject * obj8 = 0 ;
5196
EST_read_status result;
5197
5198
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOOO:EST_Wave_load_file",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7,&obj8)) SWIG_fail;
5199
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5200
if (!SWIG_IsOK(res1)) {
5201
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load_file" "', argument " "1"" of type '" "EST_Wave *""'");
5202
}
5203
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5204
{
5205
char *str; Py_ssize_t len;
5206
PyString_AsStringAndSize(obj1, &str, &len);
5207
arg2 = EST_String( str, len, 0, len );
5208
}
5209
{
5210
char *str; Py_ssize_t len;
5211
PyString_AsStringAndSize(obj2, &str, &len);
5212
arg3 = EST_String( str, len, 0, len );
5213
}
5214
ecode4 = SWIG_AsVal_int(obj3, &val4);
5215
if (!SWIG_IsOK(ecode4)) {
5216
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_load_file" "', argument " "4"" of type '" "int""'");
5217
}
5218
arg4 = static_cast< int >(val4);
5219
{
5220
char *str; Py_ssize_t len;
5221
PyString_AsStringAndSize(obj4, &str, &len);
5222
arg5 = EST_String( str, len, 0, len );
5223
}
5224
ecode6 = SWIG_AsVal_int(obj5, &val6);
5225
if (!SWIG_IsOK(ecode6)) {
5226
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "EST_Wave_load_file" "', argument " "6"" of type '" "int""'");
5227
}
5228
arg6 = static_cast< int >(val6);
5229
ecode7 = SWIG_AsVal_int(obj6, &val7);
5230
if (!SWIG_IsOK(ecode7)) {
5231
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "EST_Wave_load_file" "', argument " "7"" of type '" "int""'");
5232
}
5233
arg7 = static_cast< int >(val7);
5234
ecode8 = SWIG_AsVal_int(obj7, &val8);
5235
if (!SWIG_IsOK(ecode8)) {
5236
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "EST_Wave_load_file" "', argument " "8"" of type '" "int""'");
5237
}
5238
arg8 = static_cast< int >(val8);
5239
ecode9 = SWIG_AsVal_int(obj8, &val9);
5240
if (!SWIG_IsOK(ecode9)) {
5241
SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "EST_Wave_load_file" "', argument " "9"" of type '" "int""'");
5242
}
5243
arg9 = static_cast< int >(val9);
5244
result = (EST_read_status)(arg1)->load_file(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
5245
resultobj = SWIG_From_int(static_cast< int >(result));
5246
return resultobj;
5247
fail:
5248
return NULL;
5249
}
5250
5251
5252
SWIGINTERN PyObject *_wrap_EST_Wave_load_file__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5253
PyObject *resultobj = 0;
5254
EST_Wave *arg1 = (EST_Wave *) 0 ;
5255
EST_String arg2 ;
5256
EST_String arg3 ;
5257
int arg4 ;
5258
EST_String arg5 ;
5259
int arg6 ;
5260
int arg7 ;
5261
int arg8 ;
5262
void *argp1 = 0 ;
5263
int res1 = 0 ;
5264
int val4 ;
5265
int ecode4 = 0 ;
5266
int val6 ;
5267
int ecode6 = 0 ;
5268
int val7 ;
5269
int ecode7 = 0 ;
5270
int val8 ;
5271
int ecode8 = 0 ;
5272
PyObject * obj0 = 0 ;
5273
PyObject * obj1 = 0 ;
5274
PyObject * obj2 = 0 ;
5275
PyObject * obj3 = 0 ;
5276
PyObject * obj4 = 0 ;
5277
PyObject * obj5 = 0 ;
5278
PyObject * obj6 = 0 ;
5279
PyObject * obj7 = 0 ;
5280
EST_read_status result;
5281
5282
if (!PyArg_ParseTuple(args,(char *)"OOOOOOOO:EST_Wave_load_file",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
5283
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5284
if (!SWIG_IsOK(res1)) {
5285
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load_file" "', argument " "1"" of type '" "EST_Wave *""'");
5286
}
5287
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5288
{
5289
char *str; Py_ssize_t len;
5290
PyString_AsStringAndSize(obj1, &str, &len);
5291
arg2 = EST_String( str, len, 0, len );
5292
}
5293
{
5294
char *str; Py_ssize_t len;
5295
PyString_AsStringAndSize(obj2, &str, &len);
5296
arg3 = EST_String( str, len, 0, len );
5297
}
5298
ecode4 = SWIG_AsVal_int(obj3, &val4);
5299
if (!SWIG_IsOK(ecode4)) {
5300
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_load_file" "', argument " "4"" of type '" "int""'");
5301
}
5302
arg4 = static_cast< int >(val4);
5303
{
5304
char *str; Py_ssize_t len;
5305
PyString_AsStringAndSize(obj4, &str, &len);
5306
arg5 = EST_String( str, len, 0, len );
5307
}
5308
ecode6 = SWIG_AsVal_int(obj5, &val6);
5309
if (!SWIG_IsOK(ecode6)) {
5310
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "EST_Wave_load_file" "', argument " "6"" of type '" "int""'");
5311
}
5312
arg6 = static_cast< int >(val6);
5313
ecode7 = SWIG_AsVal_int(obj6, &val7);
5314
if (!SWIG_IsOK(ecode7)) {
5315
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "EST_Wave_load_file" "', argument " "7"" of type '" "int""'");
5316
}
5317
arg7 = static_cast< int >(val7);
5318
ecode8 = SWIG_AsVal_int(obj7, &val8);
5319
if (!SWIG_IsOK(ecode8)) {
5320
SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "EST_Wave_load_file" "', argument " "8"" of type '" "int""'");
5321
}
5322
arg8 = static_cast< int >(val8);
5323
result = (EST_read_status)(arg1)->load_file(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
5324
resultobj = SWIG_From_int(static_cast< int >(result));
5325
return resultobj;
5326
fail:
5327
return NULL;
5328
}
5329
5330
5331
SWIGINTERN PyObject *_wrap_EST_Wave_load_file__SWIG_2(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5332
PyObject *resultobj = 0;
5333
EST_Wave *arg1 = (EST_Wave *) 0 ;
5334
EST_String arg2 ;
5335
EST_String arg3 ;
5336
int arg4 ;
5337
EST_String arg5 ;
5338
int arg6 ;
5339
int arg7 ;
5340
void *argp1 = 0 ;
5341
int res1 = 0 ;
5342
int val4 ;
5343
int ecode4 = 0 ;
5344
int val6 ;
5345
int ecode6 = 0 ;
5346
int val7 ;
5347
int ecode7 = 0 ;
5348
PyObject * obj0 = 0 ;
5349
PyObject * obj1 = 0 ;
5350
PyObject * obj2 = 0 ;
5351
PyObject * obj3 = 0 ;
5352
PyObject * obj4 = 0 ;
5353
PyObject * obj5 = 0 ;
5354
PyObject * obj6 = 0 ;
5355
EST_read_status result;
5356
5357
if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:EST_Wave_load_file",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
5358
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5359
if (!SWIG_IsOK(res1)) {
5360
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_load_file" "', argument " "1"" of type '" "EST_Wave *""'");
5361
}
5362
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5363
{
5364
char *str; Py_ssize_t len;
5365
PyString_AsStringAndSize(obj1, &str, &len);
5366
arg2 = EST_String( str, len, 0, len );
5367
}
5368
{
5369
char *str; Py_ssize_t len;
5370
PyString_AsStringAndSize(obj2, &str, &len);
5371
arg3 = EST_String( str, len, 0, len );
5372
}
5373
ecode4 = SWIG_AsVal_int(obj3, &val4);
5374
if (!SWIG_IsOK(ecode4)) {
5375
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EST_Wave_load_file" "', argument " "4"" of type '" "int""'");
5376
}
5377
arg4 = static_cast< int >(val4);
5378
{
5379
char *str; Py_ssize_t len;
5380
PyString_AsStringAndSize(obj4, &str, &len);
5381
arg5 = EST_String( str, len, 0, len );
5382
}
5383
ecode6 = SWIG_AsVal_int(obj5, &val6);
5384
if (!SWIG_IsOK(ecode6)) {
5385
SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "EST_Wave_load_file" "', argument " "6"" of type '" "int""'");
5386
}
5387
arg6 = static_cast< int >(val6);
5388
ecode7 = SWIG_AsVal_int(obj6, &val7);
5389
if (!SWIG_IsOK(ecode7)) {
5390
SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "EST_Wave_load_file" "', argument " "7"" of type '" "int""'");
5391
}
5392
arg7 = static_cast< int >(val7);
5393
result = (EST_read_status)(arg1)->load_file(arg2,arg3,arg4,arg5,arg6,arg7);
5394
resultobj = SWIG_From_int(static_cast< int >(result));
5395
return resultobj;
5396
fail:
5397
return NULL;
5398
}
5399
5400
5401
SWIGINTERN PyObject *_wrap_EST_Wave_load_file(PyObject *self, PyObject *args) {
5402
int argc;
5403
PyObject *argv[10];
5404
int ii;
5405
5406
if (!PyTuple_Check(args)) SWIG_fail;
5407
argc = (int)PyObject_Length(args);
5408
for (ii = 0; (ii < argc) && (ii < 9); ii++) {
5409
argv[ii] = PyTuple_GET_ITEM(args,ii);
5410
}
5411
if (argc == 7) {
5412
int _v;
5413
void *vptr = 0;
5414
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5415
_v = SWIG_CheckState(res);
5416
if (_v) {
5417
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5418
_v = SWIG_CheckState(res);
5419
if (_v) {
5420
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
5421
_v = SWIG_CheckState(res);
5422
if (_v) {
5423
{
5424
int res = SWIG_AsVal_int(argv[3], NULL);
5425
_v = SWIG_CheckState(res);
5426
}
5427
if (_v) {
5428
int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
5429
_v = SWIG_CheckState(res);
5430
if (_v) {
5431
{
5432
int res = SWIG_AsVal_int(argv[5], NULL);
5433
_v = SWIG_CheckState(res);
5434
}
5435
if (_v) {
5436
{
5437
int res = SWIG_AsVal_int(argv[6], NULL);
5438
_v = SWIG_CheckState(res);
5439
}
5440
if (_v) {
5441
return _wrap_EST_Wave_load_file__SWIG_2(self, args);
5442
}
5443
}
5444
}
5445
}
5446
}
5447
}
5448
}
5449
}
5450
if (argc == 8) {
5451
int _v;
5452
void *vptr = 0;
5453
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5454
_v = SWIG_CheckState(res);
5455
if (_v) {
5456
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5457
_v = SWIG_CheckState(res);
5458
if (_v) {
5459
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
5460
_v = SWIG_CheckState(res);
5461
if (_v) {
5462
{
5463
int res = SWIG_AsVal_int(argv[3], NULL);
5464
_v = SWIG_CheckState(res);
5465
}
5466
if (_v) {
5467
int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
5468
_v = SWIG_CheckState(res);
5469
if (_v) {
5470
{
5471
int res = SWIG_AsVal_int(argv[5], NULL);
5472
_v = SWIG_CheckState(res);
5473
}
5474
if (_v) {
5475
{
5476
int res = SWIG_AsVal_int(argv[6], NULL);
5477
_v = SWIG_CheckState(res);
5478
}
5479
if (_v) {
5480
{
5481
int res = SWIG_AsVal_int(argv[7], NULL);
5482
_v = SWIG_CheckState(res);
5483
}
5484
if (_v) {
5485
return _wrap_EST_Wave_load_file__SWIG_1(self, args);
5486
}
5487
}
5488
}
5489
}
5490
}
5491
}
5492
}
5493
}
5494
}
5495
if (argc == 9) {
5496
int _v;
5497
void *vptr = 0;
5498
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5499
_v = SWIG_CheckState(res);
5500
if (_v) {
5501
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5502
_v = SWIG_CheckState(res);
5503
if (_v) {
5504
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
5505
_v = SWIG_CheckState(res);
5506
if (_v) {
5507
{
5508
int res = SWIG_AsVal_int(argv[3], NULL);
5509
_v = SWIG_CheckState(res);
5510
}
5511
if (_v) {
5512
int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
5513
_v = SWIG_CheckState(res);
5514
if (_v) {
5515
{
5516
int res = SWIG_AsVal_int(argv[5], NULL);
5517
_v = SWIG_CheckState(res);
5518
}
5519
if (_v) {
5520
{
5521
int res = SWIG_AsVal_int(argv[6], NULL);
5522
_v = SWIG_CheckState(res);
5523
}
5524
if (_v) {
5525
{
5526
int res = SWIG_AsVal_int(argv[7], NULL);
5527
_v = SWIG_CheckState(res);
5528
}
5529
if (_v) {
5530
{
5531
int res = SWIG_AsVal_int(argv[8], NULL);
5532
_v = SWIG_CheckState(res);
5533
}
5534
if (_v) {
5535
return _wrap_EST_Wave_load_file__SWIG_0(self, args);
5536
}
5537
}
5538
}
5539
}
5540
}
5541
}
5542
}
5543
}
5544
}
5545
}
5546
5547
fail:
5548
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_load_file'.\n"
5549
" Possible C/C++ prototypes are:\n"
5550
" load_file(EST_Wave *,EST_String const,EST_String const,int,EST_String const,int,int,int,int)\n"
5551
" load_file(EST_Wave *,EST_String const,EST_String const,int,EST_String const,int,int,int)\n"
5552
" load_file(EST_Wave *,EST_String const,EST_String const,int,EST_String const,int,int)\n");
5553
return NULL;
5554
}
5555
5556
5557
SWIGINTERN PyObject *_wrap_EST_Wave_save__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5558
PyObject *resultobj = 0;
5559
EST_Wave *arg1 = (EST_Wave *) 0 ;
5560
EST_String arg2 ;
5561
EST_String arg3 ;
5562
void *argp1 = 0 ;
5563
int res1 = 0 ;
5564
PyObject * obj0 = 0 ;
5565
PyObject * obj1 = 0 ;
5566
PyObject * obj2 = 0 ;
5567
EST_write_status result;
5568
5569
if (!PyArg_ParseTuple(args,(char *)"OOO:EST_Wave_save",&obj0,&obj1,&obj2)) SWIG_fail;
5570
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5571
if (!SWIG_IsOK(res1)) {
5572
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_save" "', argument " "1"" of type '" "EST_Wave *""'");
5573
}
5574
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5575
{
5576
char *str; Py_ssize_t len;
5577
PyString_AsStringAndSize(obj1, &str, &len);
5578
arg2 = EST_String( str, len, 0, len );
5579
}
5580
{
5581
char *str; Py_ssize_t len;
5582
PyString_AsStringAndSize(obj2, &str, &len);
5583
arg3 = EST_String( str, len, 0, len );
5584
}
5585
result = (EST_write_status)(arg1)->save(arg2,arg3);
5586
resultobj = SWIG_From_int(static_cast< int >(result));
5587
return resultobj;
5588
fail:
5589
return NULL;
5590
}
5591
5592
5593
SWIGINTERN PyObject *_wrap_EST_Wave_save__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5594
PyObject *resultobj = 0;
5595
EST_Wave *arg1 = (EST_Wave *) 0 ;
5596
EST_String arg2 ;
5597
void *argp1 = 0 ;
5598
int res1 = 0 ;
5599
PyObject * obj0 = 0 ;
5600
PyObject * obj1 = 0 ;
5601
EST_write_status result;
5602
5603
if (!PyArg_ParseTuple(args,(char *)"OO:EST_Wave_save",&obj0,&obj1)) SWIG_fail;
5604
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5605
if (!SWIG_IsOK(res1)) {
5606
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_save" "', argument " "1"" of type '" "EST_Wave *""'");
5607
}
5608
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5609
{
5610
char *str; Py_ssize_t len;
5611
PyString_AsStringAndSize(obj1, &str, &len);
5612
arg2 = EST_String( str, len, 0, len );
5613
}
5614
result = (EST_write_status)(arg1)->save(arg2);
5615
resultobj = SWIG_From_int(static_cast< int >(result));
5616
return resultobj;
5617
fail:
5618
return NULL;
5619
}
5620
5621
5622
SWIGINTERN PyObject *_wrap_EST_Wave_save(PyObject *self, PyObject *args) {
5623
int argc;
5624
PyObject *argv[4];
5625
int ii;
5626
5627
if (!PyTuple_Check(args)) SWIG_fail;
5628
argc = (int)PyObject_Length(args);
5629
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
5630
argv[ii] = PyTuple_GET_ITEM(args,ii);
5631
}
5632
if (argc == 2) {
5633
int _v;
5634
void *vptr = 0;
5635
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5636
_v = SWIG_CheckState(res);
5637
if (_v) {
5638
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5639
_v = SWIG_CheckState(res);
5640
if (_v) {
5641
return _wrap_EST_Wave_save__SWIG_1(self, args);
5642
}
5643
}
5644
}
5645
if (argc == 3) {
5646
int _v;
5647
void *vptr = 0;
5648
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
5649
_v = SWIG_CheckState(res);
5650
if (_v) {
5651
int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
5652
_v = SWIG_CheckState(res);
5653
if (_v) {
5654
int res = SWIG_AsCharPtrAndSize(argv[2], 0, NULL, 0);
5655
_v = SWIG_CheckState(res);
5656
if (_v) {
5657
return _wrap_EST_Wave_save__SWIG_0(self, args);
5658
}
5659
}
5660
}
5661
}
5662
5663
fail:
5664
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'EST_Wave_save'.\n"
5665
" Possible C/C++ prototypes are:\n"
5666
" save(EST_Wave *,EST_String const,EST_String const)\n"
5667
" save(EST_Wave *,EST_String const)\n");
5668
return NULL;
5669
}
5670
5671
5672
SWIGINTERN PyObject *_wrap_EST_Wave_save_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5673
PyObject *resultobj = 0;
5674
EST_Wave *arg1 = (EST_Wave *) 0 ;
5675
EST_String arg2 ;
5676
EST_String arg3 ;
5677
EST_String arg4 ;
5678
int arg5 ;
5679
void *argp1 = 0 ;
5680
int res1 = 0 ;
5681
int val5 ;
5682
int ecode5 = 0 ;
5683
PyObject * obj0 = 0 ;
5684
PyObject * obj1 = 0 ;
5685
PyObject * obj2 = 0 ;
5686
PyObject * obj3 = 0 ;
5687
PyObject * obj4 = 0 ;
5688
EST_write_status result;
5689
5690
if (!PyArg_ParseTuple(args,(char *)"OOOOO:EST_Wave_save_file",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
5691
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5692
if (!SWIG_IsOK(res1)) {
5693
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_save_file" "', argument " "1"" of type '" "EST_Wave *""'");
5694
}
5695
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5696
{
5697
char *str; Py_ssize_t len;
5698
PyString_AsStringAndSize(obj1, &str, &len);
5699
arg2 = EST_String( str, len, 0, len );
5700
}
5701
{
5702
char *str; Py_ssize_t len;
5703
PyString_AsStringAndSize(obj2, &str, &len);
5704
arg3 = EST_String( str, len, 0, len );
5705
}
5706
{
5707
char *str; Py_ssize_t len;
5708
PyString_AsStringAndSize(obj3, &str, &len);
5709
arg4 = EST_String( str, len, 0, len );
5710
}
5711
ecode5 = SWIG_AsVal_int(obj4, &val5);
5712
if (!SWIG_IsOK(ecode5)) {
5713
SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "EST_Wave_save_file" "', argument " "5"" of type '" "int""'");
5714
}
5715
arg5 = static_cast< int >(val5);
5716
result = (EST_write_status)(arg1)->save_file(arg2,arg3,arg4,arg5);
5717
resultobj = SWIG_From_int(static_cast< int >(result));
5718
return resultobj;
5719
fail:
5720
return NULL;
5721
}
5722
5723
5724
SWIGINTERN PyObject *_wrap_EST_Wave_integrity(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5725
PyObject *resultobj = 0;
5726
EST_Wave *arg1 = (EST_Wave *) 0 ;
5727
void *argp1 = 0 ;
5728
int res1 = 0 ;
5729
PyObject * obj0 = 0 ;
5730
5731
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_integrity",&obj0)) SWIG_fail;
5732
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5733
if (!SWIG_IsOK(res1)) {
5734
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_integrity" "', argument " "1"" of type '" "EST_Wave const *""'");
5735
}
5736
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5737
((EST_Wave const *)arg1)->integrity();
5738
resultobj = SWIG_Py_Void();
5739
return resultobj;
5740
fail:
5741
return NULL;
5742
}
5743
5744
5745
SWIGINTERN PyObject *_wrap_EST_Wave_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5746
PyObject *resultobj = 0;
5747
EST_Wave *arg1 = (EST_Wave *) 0 ;
5748
void *argp1 = 0 ;
5749
int res1 = 0 ;
5750
PyObject * obj0 = 0 ;
5751
5752
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_info",&obj0)) SWIG_fail;
5753
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5754
if (!SWIG_IsOK(res1)) {
5755
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_info" "', argument " "1"" of type '" "EST_Wave *""'");
5756
}
5757
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5758
EST_Wave_info(arg1);
5759
resultobj = SWIG_Py_Void();
5760
return resultobj;
5761
fail:
5762
return NULL;
5763
}
5764
5765
5766
SWIGINTERN PyObject *_wrap_EST_Wave_play(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5767
PyObject *resultobj = 0;
5768
EST_Wave *arg1 = (EST_Wave *) 0 ;
5769
void *argp1 = 0 ;
5770
int res1 = 0 ;
5771
PyObject * obj0 = 0 ;
5772
5773
if (!PyArg_ParseTuple(args,(char *)"O:EST_Wave_play",&obj0)) SWIG_fail;
5774
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_EST_Wave, 0 | 0 );
5775
if (!SWIG_IsOK(res1)) {
5776
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EST_Wave_play" "', argument " "1"" of type '" "EST_Wave *""'");
5777
}
5778
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5779
EST_Wave_play(arg1);
5780
resultobj = SWIG_Py_Void();
5781
return resultobj;
5782
fail:
5783
return NULL;
5784
}
5785
5786
5787
SWIGINTERN PyObject *EST_Wave_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5788
PyObject *obj;
5789
if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5790
SWIG_TypeNewClientData(SWIGTYPE_p_EST_Wave, SWIG_NewClientData(obj));
5791
return SWIG_Py_Void();
5792
}
5793
5794
SWIGINTERN PyObject *_wrap_wave_extract_channel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5795
PyObject *resultobj = 0;
5796
EST_Wave *arg1 = 0 ;
5797
EST_Wave *arg2 = 0 ;
5798
int arg3 ;
5799
void *argp1 = 0 ;
5800
int res1 = 0 ;
5801
void *argp2 = 0 ;
5802
int res2 = 0 ;
5803
int val3 ;
5804
int ecode3 = 0 ;
5805
PyObject * obj0 = 0 ;
5806
PyObject * obj1 = 0 ;
5807
PyObject * obj2 = 0 ;
5808
int result;
5809
5810
if (!PyArg_ParseTuple(args,(char *)"OOO:wave_extract_channel",&obj0,&obj1,&obj2)) SWIG_fail;
5811
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
5812
if (!SWIG_IsOK(res1)) {
5813
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_extract_channel" "', argument " "1"" of type '" "EST_Wave &""'");
5814
}
5815
if (!argp1) {
5816
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_extract_channel" "', argument " "1"" of type '" "EST_Wave &""'");
5817
}
5818
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5819
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 | 0);
5820
if (!SWIG_IsOK(res2)) {
5821
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wave_extract_channel" "', argument " "2"" of type '" "EST_Wave const &""'");
5822
}
5823
if (!argp2) {
5824
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_extract_channel" "', argument " "2"" of type '" "EST_Wave const &""'");
5825
}
5826
arg2 = reinterpret_cast< EST_Wave * >(argp2);
5827
ecode3 = SWIG_AsVal_int(obj2, &val3);
5828
if (!SWIG_IsOK(ecode3)) {
5829
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wave_extract_channel" "', argument " "3"" of type '" "int""'");
5830
}
5831
arg3 = static_cast< int >(val3);
5832
result = (int)wave_extract_channel(*arg1,(EST_Wave const &)*arg2,arg3);
5833
resultobj = SWIG_From_int(static_cast< int >(result));
5834
return resultobj;
5835
fail:
5836
return NULL;
5837
}
5838
5839
5840
SWIGINTERN PyObject *_wrap_wave_combine_channels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5841
PyObject *resultobj = 0;
5842
EST_Wave *arg1 = 0 ;
5843
EST_Wave *arg2 = 0 ;
5844
void *argp1 = 0 ;
5845
int res1 = 0 ;
5846
void *argp2 = 0 ;
5847
int res2 = 0 ;
5848
PyObject * obj0 = 0 ;
5849
PyObject * obj1 = 0 ;
5850
5851
if (!PyArg_ParseTuple(args,(char *)"OO:wave_combine_channels",&obj0,&obj1)) SWIG_fail;
5852
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
5853
if (!SWIG_IsOK(res1)) {
5854
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_combine_channels" "', argument " "1"" of type '" "EST_Wave &""'");
5855
}
5856
if (!argp1) {
5857
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_combine_channels" "', argument " "1"" of type '" "EST_Wave &""'");
5858
}
5859
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5860
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 | 0);
5861
if (!SWIG_IsOK(res2)) {
5862
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wave_combine_channels" "', argument " "2"" of type '" "EST_Wave const &""'");
5863
}
5864
if (!argp2) {
5865
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_combine_channels" "', argument " "2"" of type '" "EST_Wave const &""'");
5866
}
5867
arg2 = reinterpret_cast< EST_Wave * >(argp2);
5868
wave_combine_channels(*arg1,(EST_Wave const &)*arg2);
5869
resultobj = SWIG_Py_Void();
5870
return resultobj;
5871
fail:
5872
return NULL;
5873
}
5874
5875
5876
SWIGINTERN PyObject *_wrap_wave_subwave(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5877
PyObject *resultobj = 0;
5878
EST_Wave *arg1 = 0 ;
5879
EST_Wave *arg2 = 0 ;
5880
int arg3 ;
5881
int arg4 ;
5882
void *argp1 = 0 ;
5883
int res1 = 0 ;
5884
void *argp2 = 0 ;
5885
int res2 = 0 ;
5886
int val3 ;
5887
int ecode3 = 0 ;
5888
int val4 ;
5889
int ecode4 = 0 ;
5890
PyObject * obj0 = 0 ;
5891
PyObject * obj1 = 0 ;
5892
PyObject * obj2 = 0 ;
5893
PyObject * obj3 = 0 ;
5894
int result;
5895
5896
if (!PyArg_ParseTuple(args,(char *)"OOOO:wave_subwave",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5897
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
5898
if (!SWIG_IsOK(res1)) {
5899
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_subwave" "', argument " "1"" of type '" "EST_Wave &""'");
5900
}
5901
if (!argp1) {
5902
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_subwave" "', argument " "1"" of type '" "EST_Wave &""'");
5903
}
5904
arg1 = reinterpret_cast< EST_Wave * >(argp1);
5905
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
5906
if (!SWIG_IsOK(res2)) {
5907
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wave_subwave" "', argument " "2"" of type '" "EST_Wave &""'");
5908
}
5909
if (!argp2) {
5910
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_subwave" "', argument " "2"" of type '" "EST_Wave &""'");
5911
}
5912
arg2 = reinterpret_cast< EST_Wave * >(argp2);
5913
ecode3 = SWIG_AsVal_int(obj2, &val3);
5914
if (!SWIG_IsOK(ecode3)) {
5915
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "wave_subwave" "', argument " "3"" of type '" "int""'");
5916
}
5917
arg3 = static_cast< int >(val3);
5918
ecode4 = SWIG_AsVal_int(obj3, &val4);
5919
if (!SWIG_IsOK(ecode4)) {
5920
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "wave_subwave" "', argument " "4"" of type '" "int""'");
5921
}
5922
arg4 = static_cast< int >(val4);
5923
result = (int)wave_subwave(*arg1,*arg2,arg3,arg4);
5924
resultobj = SWIG_From_int(static_cast< int >(result));
5925
return resultobj;
5926
fail:
5927
return NULL;
5928
}
5929
5930
5931
SWIGINTERN PyObject *_wrap_wave_divide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5932
PyObject *resultobj = 0;
5933
EST_WaveList *arg1 = 0 ;
5934
EST_Wave *arg2 = 0 ;
5935
EST_Relation *arg3 = 0 ;
5936
EST_String *arg4 = 0 ;
5937
void *argp1 = 0 ;
5938
int res1 = 0 ;
5939
void *argp2 = 0 ;
5940
int res2 = 0 ;
5941
void *argp3 = 0 ;
5942
int res3 = 0 ;
5943
EST_String temp4 ;
5944
PyObject * obj0 = 0 ;
5945
PyObject * obj1 = 0 ;
5946
PyObject * obj2 = 0 ;
5947
PyObject * obj3 = 0 ;
5948
int result;
5949
5950
if (!PyArg_ParseTuple(args,(char *)"OOOO:wave_divide",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
5951
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_WaveList, 0 );
5952
if (!SWIG_IsOK(res1)) {
5953
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_divide" "', argument " "1"" of type '" "EST_WaveList &""'");
5954
}
5955
if (!argp1) {
5956
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_divide" "', argument " "1"" of type '" "EST_WaveList &""'");
5957
}
5958
arg1 = reinterpret_cast< EST_WaveList * >(argp1);
5959
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
5960
if (!SWIG_IsOK(res2)) {
5961
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wave_divide" "', argument " "2"" of type '" "EST_Wave &""'");
5962
}
5963
if (!argp2) {
5964
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_divide" "', argument " "2"" of type '" "EST_Wave &""'");
5965
}
5966
arg2 = reinterpret_cast< EST_Wave * >(argp2);
5967
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_EST_Relation, 0 );
5968
if (!SWIG_IsOK(res3)) {
5969
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wave_divide" "', argument " "3"" of type '" "EST_Relation &""'");
5970
}
5971
if (!argp3) {
5972
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_divide" "', argument " "3"" of type '" "EST_Relation &""'");
5973
}
5974
arg3 = reinterpret_cast< EST_Relation * >(argp3);
5975
{
5976
char *str; Py_ssize_t len;
5977
PyString_AsStringAndSize(obj3, &str, &len);
5978
temp4 = EST_String( str, len, 0, len );
5979
arg4 = &temp4;
5980
}
5981
result = (int)wave_divide(*arg1,*arg2,*arg3,(EST_String const &)*arg4);
5982
resultobj = SWIG_From_int(static_cast< int >(result));
5983
return resultobj;
5984
fail:
5985
return NULL;
5986
}
5987
5988
5989
SWIGINTERN PyObject *_wrap_wave_extract(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5990
PyObject *resultobj = 0;
5991
EST_Wave *arg1 = 0 ;
5992
EST_Wave *arg2 = 0 ;
5993
EST_Relation *arg3 = 0 ;
5994
EST_String *arg4 = 0 ;
5995
void *argp1 = 0 ;
5996
int res1 = 0 ;
5997
void *argp2 = 0 ;
5998
int res2 = 0 ;
5999
void *argp3 = 0 ;
6000
int res3 = 0 ;
6001
EST_String temp4 ;
6002
PyObject * obj0 = 0 ;
6003
PyObject * obj1 = 0 ;
6004
PyObject * obj2 = 0 ;
6005
PyObject * obj3 = 0 ;
6006
int result;
6007
6008
if (!PyArg_ParseTuple(args,(char *)"OOOO:wave_extract",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6009
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6010
if (!SWIG_IsOK(res1)) {
6011
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_extract" "', argument " "1"" of type '" "EST_Wave &""'");
6012
}
6013
if (!argp1) {
6014
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_extract" "', argument " "1"" of type '" "EST_Wave &""'");
6015
}
6016
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6017
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6018
if (!SWIG_IsOK(res2)) {
6019
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "wave_extract" "', argument " "2"" of type '" "EST_Wave &""'");
6020
}
6021
if (!argp2) {
6022
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_extract" "', argument " "2"" of type '" "EST_Wave &""'");
6023
}
6024
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6025
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_EST_Relation, 0 );
6026
if (!SWIG_IsOK(res3)) {
6027
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "wave_extract" "', argument " "3"" of type '" "EST_Relation &""'");
6028
}
6029
if (!argp3) {
6030
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_extract" "', argument " "3"" of type '" "EST_Relation &""'");
6031
}
6032
arg3 = reinterpret_cast< EST_Relation * >(argp3);
6033
{
6034
char *str; Py_ssize_t len;
6035
PyString_AsStringAndSize(obj3, &str, &len);
6036
temp4 = EST_String( str, len, 0, len );
6037
arg4 = &temp4;
6038
}
6039
result = (int)wave_extract(*arg1,*arg2,*arg3,(EST_String const &)*arg4);
6040
resultobj = SWIG_From_int(static_cast< int >(result));
6041
return resultobj;
6042
fail:
6043
return NULL;
6044
}
6045
6046
6047
SWIGINTERN PyObject *_wrap_add_waves(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6048
PyObject *resultobj = 0;
6049
EST_Wave *arg1 = 0 ;
6050
EST_Wave *arg2 = 0 ;
6051
void *argp1 = 0 ;
6052
int res1 = 0 ;
6053
void *argp2 = 0 ;
6054
int res2 = 0 ;
6055
PyObject * obj0 = 0 ;
6056
PyObject * obj1 = 0 ;
6057
6058
if (!PyArg_ParseTuple(args,(char *)"OO:add_waves",&obj0,&obj1)) SWIG_fail;
6059
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6060
if (!SWIG_IsOK(res1)) {
6061
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "add_waves" "', argument " "1"" of type '" "EST_Wave &""'");
6062
}
6063
if (!argp1) {
6064
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "add_waves" "', argument " "1"" of type '" "EST_Wave &""'");
6065
}
6066
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6067
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 | 0);
6068
if (!SWIG_IsOK(res2)) {
6069
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "add_waves" "', argument " "2"" of type '" "EST_Wave const &""'");
6070
}
6071
if (!argp2) {
6072
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "add_waves" "', argument " "2"" of type '" "EST_Wave const &""'");
6073
}
6074
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6075
add_waves(*arg1,(EST_Wave const &)*arg2);
6076
resultobj = SWIG_Py_Void();
6077
return resultobj;
6078
fail:
6079
return NULL;
6080
}
6081
6082
6083
SWIGINTERN PyObject *_wrap_difference(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6084
PyObject *resultobj = 0;
6085
EST_Wave *arg1 = 0 ;
6086
EST_Wave *arg2 = 0 ;
6087
void *argp1 = 0 ;
6088
int res1 = 0 ;
6089
void *argp2 = 0 ;
6090
int res2 = 0 ;
6091
PyObject * obj0 = 0 ;
6092
PyObject * obj1 = 0 ;
6093
EST_Wave result;
6094
6095
if (!PyArg_ParseTuple(args,(char *)"OO:difference",&obj0,&obj1)) SWIG_fail;
6096
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6097
if (!SWIG_IsOK(res1)) {
6098
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "difference" "', argument " "1"" of type '" "EST_Wave &""'");
6099
}
6100
if (!argp1) {
6101
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "difference" "', argument " "1"" of type '" "EST_Wave &""'");
6102
}
6103
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6104
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6105
if (!SWIG_IsOK(res2)) {
6106
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "difference" "', argument " "2"" of type '" "EST_Wave &""'");
6107
}
6108
if (!argp2) {
6109
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "difference" "', argument " "2"" of type '" "EST_Wave &""'");
6110
}
6111
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6112
result = difference(*arg1,*arg2);
6113
resultobj = SWIG_NewPointerObj((new EST_Wave(static_cast< const EST_Wave& >(result))), SWIGTYPE_p_EST_Wave, SWIG_POINTER_OWN | 0 );
6114
return resultobj;
6115
fail:
6116
return NULL;
6117
}
6118
6119
6120
SWIGINTERN PyObject *_wrap_rms_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6121
PyObject *resultobj = 0;
6122
EST_Wave *arg1 = 0 ;
6123
EST_Wave *arg2 = 0 ;
6124
int arg3 ;
6125
void *argp1 = 0 ;
6126
int res1 = 0 ;
6127
void *argp2 = 0 ;
6128
int res2 = 0 ;
6129
int val3 ;
6130
int ecode3 = 0 ;
6131
PyObject * obj0 = 0 ;
6132
PyObject * obj1 = 0 ;
6133
PyObject * obj2 = 0 ;
6134
float result;
6135
6136
if (!PyArg_ParseTuple(args,(char *)"OOO:rms_error",&obj0,&obj1,&obj2)) SWIG_fail;
6137
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6138
if (!SWIG_IsOK(res1)) {
6139
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rms_error" "', argument " "1"" of type '" "EST_Wave &""'");
6140
}
6141
if (!argp1) {
6142
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rms_error" "', argument " "1"" of type '" "EST_Wave &""'");
6143
}
6144
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6145
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6146
if (!SWIG_IsOK(res2)) {
6147
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rms_error" "', argument " "2"" of type '" "EST_Wave &""'");
6148
}
6149
if (!argp2) {
6150
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rms_error" "', argument " "2"" of type '" "EST_Wave &""'");
6151
}
6152
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6153
ecode3 = SWIG_AsVal_int(obj2, &val3);
6154
if (!SWIG_IsOK(ecode3)) {
6155
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "rms_error" "', argument " "3"" of type '" "int""'");
6156
}
6157
arg3 = static_cast< int >(val3);
6158
result = (float)rms_error(*arg1,*arg2,arg3);
6159
resultobj = SWIG_From_float(static_cast< float >(result));
6160
return resultobj;
6161
fail:
6162
return NULL;
6163
}
6164
6165
6166
SWIGINTERN PyObject *_wrap_abs_error__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6167
PyObject *resultobj = 0;
6168
EST_Wave *arg1 = 0 ;
6169
EST_Wave *arg2 = 0 ;
6170
int arg3 ;
6171
void *argp1 = 0 ;
6172
int res1 = 0 ;
6173
void *argp2 = 0 ;
6174
int res2 = 0 ;
6175
int val3 ;
6176
int ecode3 = 0 ;
6177
PyObject * obj0 = 0 ;
6178
PyObject * obj1 = 0 ;
6179
PyObject * obj2 = 0 ;
6180
float result;
6181
6182
if (!PyArg_ParseTuple(args,(char *)"OOO:abs_error",&obj0,&obj1,&obj2)) SWIG_fail;
6183
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6184
if (!SWIG_IsOK(res1)) {
6185
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abs_error" "', argument " "1"" of type '" "EST_Wave &""'");
6186
}
6187
if (!argp1) {
6188
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "abs_error" "', argument " "1"" of type '" "EST_Wave &""'");
6189
}
6190
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6191
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6192
if (!SWIG_IsOK(res2)) {
6193
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abs_error" "', argument " "2"" of type '" "EST_Wave &""'");
6194
}
6195
if (!argp2) {
6196
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "abs_error" "', argument " "2"" of type '" "EST_Wave &""'");
6197
}
6198
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6199
ecode3 = SWIG_AsVal_int(obj2, &val3);
6200
if (!SWIG_IsOK(ecode3)) {
6201
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "abs_error" "', argument " "3"" of type '" "int""'");
6202
}
6203
arg3 = static_cast< int >(val3);
6204
result = (float)abs_error(*arg1,*arg2,arg3);
6205
resultobj = SWIG_From_float(static_cast< float >(result));
6206
return resultobj;
6207
fail:
6208
return NULL;
6209
}
6210
6211
6212
SWIGINTERN PyObject *_wrap_correlation__SWIG_0(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6213
PyObject *resultobj = 0;
6214
EST_Wave *arg1 = 0 ;
6215
EST_Wave *arg2 = 0 ;
6216
int arg3 ;
6217
void *argp1 = 0 ;
6218
int res1 = 0 ;
6219
void *argp2 = 0 ;
6220
int res2 = 0 ;
6221
int val3 ;
6222
int ecode3 = 0 ;
6223
PyObject * obj0 = 0 ;
6224
PyObject * obj1 = 0 ;
6225
PyObject * obj2 = 0 ;
6226
float result;
6227
6228
if (!PyArg_ParseTuple(args,(char *)"OOO:correlation",&obj0,&obj1,&obj2)) SWIG_fail;
6229
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6230
if (!SWIG_IsOK(res1)) {
6231
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correlation" "', argument " "1"" of type '" "EST_Wave &""'");
6232
}
6233
if (!argp1) {
6234
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "correlation" "', argument " "1"" of type '" "EST_Wave &""'");
6235
}
6236
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6237
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6238
if (!SWIG_IsOK(res2)) {
6239
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "correlation" "', argument " "2"" of type '" "EST_Wave &""'");
6240
}
6241
if (!argp2) {
6242
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "correlation" "', argument " "2"" of type '" "EST_Wave &""'");
6243
}
6244
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6245
ecode3 = SWIG_AsVal_int(obj2, &val3);
6246
if (!SWIG_IsOK(ecode3)) {
6247
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "correlation" "', argument " "3"" of type '" "int""'");
6248
}
6249
arg3 = static_cast< int >(val3);
6250
result = (float)correlation(*arg1,*arg2,arg3);
6251
resultobj = SWIG_From_float(static_cast< float >(result));
6252
return resultobj;
6253
fail:
6254
return NULL;
6255
}
6256
6257
6258
SWIGINTERN PyObject *_wrap_rms_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6259
PyObject *resultobj = 0;
6260
EST_Wave *arg1 = 0 ;
6261
EST_Wave *arg2 = 0 ;
6262
void *argp1 = 0 ;
6263
int res1 = 0 ;
6264
void *argp2 = 0 ;
6265
int res2 = 0 ;
6266
PyObject * obj0 = 0 ;
6267
PyObject * obj1 = 0 ;
6268
EST_FVector result;
6269
6270
if (!PyArg_ParseTuple(args,(char *)"OO:rms_error",&obj0,&obj1)) SWIG_fail;
6271
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6272
if (!SWIG_IsOK(res1)) {
6273
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "rms_error" "', argument " "1"" of type '" "EST_Wave &""'");
6274
}
6275
if (!argp1) {
6276
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rms_error" "', argument " "1"" of type '" "EST_Wave &""'");
6277
}
6278
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6279
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6280
if (!SWIG_IsOK(res2)) {
6281
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "rms_error" "', argument " "2"" of type '" "EST_Wave &""'");
6282
}
6283
if (!argp2) {
6284
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "rms_error" "', argument " "2"" of type '" "EST_Wave &""'");
6285
}
6286
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6287
result = rms_error(*arg1,*arg2);
6288
resultobj = SWIG_NewPointerObj((new EST_FVector(static_cast< const EST_FVector& >(result))), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
6289
return resultobj;
6290
fail:
6291
return NULL;
6292
}
6293
6294
6295
SWIGINTERN PyObject *_wrap_rms_error(PyObject *self, PyObject *args) {
6296
int argc;
6297
PyObject *argv[4];
6298
int ii;
6299
6300
if (!PyTuple_Check(args)) SWIG_fail;
6301
argc = (int)PyObject_Length(args);
6302
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6303
argv[ii] = PyTuple_GET_ITEM(args,ii);
6304
}
6305
if (argc == 2) {
6306
int _v;
6307
void *vptr = 0;
6308
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6309
_v = SWIG_CheckState(res);
6310
if (_v) {
6311
void *vptr = 0;
6312
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6313
_v = SWIG_CheckState(res);
6314
if (_v) {
6315
return _wrap_rms_error__SWIG_1(self, args);
6316
}
6317
}
6318
}
6319
if (argc == 3) {
6320
int _v;
6321
void *vptr = 0;
6322
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6323
_v = SWIG_CheckState(res);
6324
if (_v) {
6325
void *vptr = 0;
6326
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6327
_v = SWIG_CheckState(res);
6328
if (_v) {
6329
{
6330
int res = SWIG_AsVal_int(argv[2], NULL);
6331
_v = SWIG_CheckState(res);
6332
}
6333
if (_v) {
6334
return _wrap_rms_error__SWIG_0(self, args);
6335
}
6336
}
6337
}
6338
}
6339
6340
fail:
6341
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'rms_error'.\n"
6342
" Possible C/C++ prototypes are:\n"
6343
" rms_error(EST_Wave &,EST_Wave &,int)\n"
6344
" rms_error(EST_Wave &,EST_Wave &)\n");
6345
return NULL;
6346
}
6347
6348
6349
SWIGINTERN PyObject *_wrap_abs_error__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6350
PyObject *resultobj = 0;
6351
EST_Wave *arg1 = 0 ;
6352
EST_Wave *arg2 = 0 ;
6353
void *argp1 = 0 ;
6354
int res1 = 0 ;
6355
void *argp2 = 0 ;
6356
int res2 = 0 ;
6357
PyObject * obj0 = 0 ;
6358
PyObject * obj1 = 0 ;
6359
EST_FVector result;
6360
6361
if (!PyArg_ParseTuple(args,(char *)"OO:abs_error",&obj0,&obj1)) SWIG_fail;
6362
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6363
if (!SWIG_IsOK(res1)) {
6364
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "abs_error" "', argument " "1"" of type '" "EST_Wave &""'");
6365
}
6366
if (!argp1) {
6367
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "abs_error" "', argument " "1"" of type '" "EST_Wave &""'");
6368
}
6369
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6370
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6371
if (!SWIG_IsOK(res2)) {
6372
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "abs_error" "', argument " "2"" of type '" "EST_Wave &""'");
6373
}
6374
if (!argp2) {
6375
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "abs_error" "', argument " "2"" of type '" "EST_Wave &""'");
6376
}
6377
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6378
result = abs_error(*arg1,*arg2);
6379
resultobj = SWIG_NewPointerObj((new EST_FVector(static_cast< const EST_FVector& >(result))), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
6380
return resultobj;
6381
fail:
6382
return NULL;
6383
}
6384
6385
6386
SWIGINTERN PyObject *_wrap_abs_error(PyObject *self, PyObject *args) {
6387
int argc;
6388
PyObject *argv[4];
6389
int ii;
6390
6391
if (!PyTuple_Check(args)) SWIG_fail;
6392
argc = (int)PyObject_Length(args);
6393
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6394
argv[ii] = PyTuple_GET_ITEM(args,ii);
6395
}
6396
if (argc == 2) {
6397
int _v;
6398
void *vptr = 0;
6399
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6400
_v = SWIG_CheckState(res);
6401
if (_v) {
6402
void *vptr = 0;
6403
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6404
_v = SWIG_CheckState(res);
6405
if (_v) {
6406
return _wrap_abs_error__SWIG_1(self, args);
6407
}
6408
}
6409
}
6410
if (argc == 3) {
6411
int _v;
6412
void *vptr = 0;
6413
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6414
_v = SWIG_CheckState(res);
6415
if (_v) {
6416
void *vptr = 0;
6417
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6418
_v = SWIG_CheckState(res);
6419
if (_v) {
6420
{
6421
int res = SWIG_AsVal_int(argv[2], NULL);
6422
_v = SWIG_CheckState(res);
6423
}
6424
if (_v) {
6425
return _wrap_abs_error__SWIG_0(self, args);
6426
}
6427
}
6428
}
6429
}
6430
6431
fail:
6432
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'abs_error'.\n"
6433
" Possible C/C++ prototypes are:\n"
6434
" abs_error(EST_Wave &,EST_Wave &,int)\n"
6435
" abs_error(EST_Wave &,EST_Wave &)\n");
6436
return NULL;
6437
}
6438
6439
6440
SWIGINTERN PyObject *_wrap_correlation__SWIG_1(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6441
PyObject *resultobj = 0;
6442
EST_Wave *arg1 = 0 ;
6443
EST_Wave *arg2 = 0 ;
6444
void *argp1 = 0 ;
6445
int res1 = 0 ;
6446
void *argp2 = 0 ;
6447
int res2 = 0 ;
6448
PyObject * obj0 = 0 ;
6449
PyObject * obj1 = 0 ;
6450
EST_FVector result;
6451
6452
if (!PyArg_ParseTuple(args,(char *)"OO:correlation",&obj0,&obj1)) SWIG_fail;
6453
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6454
if (!SWIG_IsOK(res1)) {
6455
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "correlation" "', argument " "1"" of type '" "EST_Wave &""'");
6456
}
6457
if (!argp1) {
6458
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "correlation" "', argument " "1"" of type '" "EST_Wave &""'");
6459
}
6460
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6461
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6462
if (!SWIG_IsOK(res2)) {
6463
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "correlation" "', argument " "2"" of type '" "EST_Wave &""'");
6464
}
6465
if (!argp2) {
6466
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "correlation" "', argument " "2"" of type '" "EST_Wave &""'");
6467
}
6468
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6469
result = correlation(*arg1,*arg2);
6470
resultobj = SWIG_NewPointerObj((new EST_FVector(static_cast< const EST_FVector& >(result))), SWIGTYPE_p_EST_FVector, SWIG_POINTER_OWN | 0 );
6471
return resultobj;
6472
fail:
6473
return NULL;
6474
}
6475
6476
6477
SWIGINTERN PyObject *_wrap_correlation(PyObject *self, PyObject *args) {
6478
int argc;
6479
PyObject *argv[4];
6480
int ii;
6481
6482
if (!PyTuple_Check(args)) SWIG_fail;
6483
argc = (int)PyObject_Length(args);
6484
for (ii = 0; (ii < argc) && (ii < 3); ii++) {
6485
argv[ii] = PyTuple_GET_ITEM(args,ii);
6486
}
6487
if (argc == 2) {
6488
int _v;
6489
void *vptr = 0;
6490
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6491
_v = SWIG_CheckState(res);
6492
if (_v) {
6493
void *vptr = 0;
6494
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6495
_v = SWIG_CheckState(res);
6496
if (_v) {
6497
return _wrap_correlation__SWIG_1(self, args);
6498
}
6499
}
6500
}
6501
if (argc == 3) {
6502
int _v;
6503
void *vptr = 0;
6504
int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_EST_Wave, 0);
6505
_v = SWIG_CheckState(res);
6506
if (_v) {
6507
void *vptr = 0;
6508
int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_EST_Wave, 0);
6509
_v = SWIG_CheckState(res);
6510
if (_v) {
6511
{
6512
int res = SWIG_AsVal_int(argv[2], NULL);
6513
_v = SWIG_CheckState(res);
6514
}
6515
if (_v) {
6516
return _wrap_correlation__SWIG_0(self, args);
6517
}
6518
}
6519
}
6520
}
6521
6522
fail:
6523
SWIG_SetErrorMsg(PyExc_NotImplementedError,"Wrong number of arguments for overloaded function 'correlation'.\n"
6524
" Possible C/C++ prototypes are:\n"
6525
" correlation(EST_Wave &,EST_Wave &,int)\n"
6526
" correlation(EST_Wave &,EST_Wave &)\n");
6527
return NULL;
6528
}
6529
6530
6531
SWIGINTERN PyObject *_wrap_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6532
PyObject *resultobj = 0;
6533
EST_Wave *arg1 = 0 ;
6534
EST_Wave *arg2 = 0 ;
6535
int arg3 ;
6536
void *argp1 = 0 ;
6537
int res1 = 0 ;
6538
void *argp2 = 0 ;
6539
int res2 = 0 ;
6540
int val3 ;
6541
int ecode3 = 0 ;
6542
PyObject * obj0 = 0 ;
6543
PyObject * obj1 = 0 ;
6544
PyObject * obj2 = 0 ;
6545
EST_Wave result;
6546
6547
if (!PyArg_ParseTuple(args,(char *)"OOO:error",&obj0,&obj1,&obj2)) SWIG_fail;
6548
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6549
if (!SWIG_IsOK(res1)) {
6550
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "error" "', argument " "1"" of type '" "EST_Wave &""'");
6551
}
6552
if (!argp1) {
6553
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error" "', argument " "1"" of type '" "EST_Wave &""'");
6554
}
6555
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6556
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_EST_Wave, 0 );
6557
if (!SWIG_IsOK(res2)) {
6558
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "error" "', argument " "2"" of type '" "EST_Wave &""'");
6559
}
6560
if (!argp2) {
6561
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "error" "', argument " "2"" of type '" "EST_Wave &""'");
6562
}
6563
arg2 = reinterpret_cast< EST_Wave * >(argp2);
6564
ecode3 = SWIG_AsVal_int(obj2, &val3);
6565
if (!SWIG_IsOK(ecode3)) {
6566
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "error" "', argument " "3"" of type '" "int""'");
6567
}
6568
arg3 = static_cast< int >(val3);
6569
result = error(*arg1,*arg2,arg3);
6570
resultobj = SWIG_NewPointerObj((new EST_Wave(static_cast< const EST_Wave& >(result))), SWIGTYPE_p_EST_Wave, SWIG_POINTER_OWN | 0 );
6571
return resultobj;
6572
fail:
6573
return NULL;
6574
}
6575
6576
6577
SWIGINTERN PyObject *_wrap_absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6578
PyObject *resultobj = 0;
6579
EST_Wave *arg1 = 0 ;
6580
void *argp1 = 0 ;
6581
int res1 = 0 ;
6582
PyObject * obj0 = 0 ;
6583
6584
if (!PyArg_ParseTuple(args,(char *)"O:absolute",&obj0)) SWIG_fail;
6585
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6586
if (!SWIG_IsOK(res1)) {
6587
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "absolute" "', argument " "1"" of type '" "EST_Wave &""'");
6588
}
6589
if (!argp1) {
6590
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "absolute" "', argument " "1"" of type '" "EST_Wave &""'");
6591
}
6592
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6593
absolute(*arg1);
6594
resultobj = SWIG_Py_Void();
6595
return resultobj;
6596
fail:
6597
return NULL;
6598
}
6599
6600
6601
SWIGINTERN PyObject *_wrap_wave_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6602
PyObject *resultobj = 0;
6603
EST_Wave *arg1 = 0 ;
6604
void *argp1 = 0 ;
6605
int res1 = 0 ;
6606
PyObject * obj0 = 0 ;
6607
6608
if (!PyArg_ParseTuple(args,(char *)"O:wave_info",&obj0)) SWIG_fail;
6609
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6610
if (!SWIG_IsOK(res1)) {
6611
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "wave_info" "', argument " "1"" of type '" "EST_Wave &""'");
6612
}
6613
if (!argp1) {
6614
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "wave_info" "', argument " "1"" of type '" "EST_Wave &""'");
6615
}
6616
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6617
wave_info(*arg1);
6618
resultobj = SWIG_Py_Void();
6619
return resultobj;
6620
fail:
6621
return NULL;
6622
}
6623
6624
6625
SWIGINTERN PyObject *_wrap_invert(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6626
PyObject *resultobj = 0;
6627
EST_Wave *arg1 = 0 ;
6628
void *argp1 = 0 ;
6629
int res1 = 0 ;
6630
PyObject * obj0 = 0 ;
6631
6632
if (!PyArg_ParseTuple(args,(char *)"O:invert",&obj0)) SWIG_fail;
6633
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6634
if (!SWIG_IsOK(res1)) {
6635
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "invert" "', argument " "1"" of type '" "EST_Wave &""'");
6636
}
6637
if (!argp1) {
6638
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "invert" "', argument " "1"" of type '" "EST_Wave &""'");
6639
}
6640
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6641
invert(*arg1);
6642
resultobj = SWIG_Py_Void();
6643
return resultobj;
6644
fail:
6645
return NULL;
6646
}
6647
6648
6649
SWIGINTERN PyObject *_wrap_differentiate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6650
PyObject *resultobj = 0;
6651
EST_Wave *arg1 = 0 ;
6652
void *argp1 = 0 ;
6653
int res1 = 0 ;
6654
PyObject * obj0 = 0 ;
6655
6656
if (!PyArg_ParseTuple(args,(char *)"O:differentiate",&obj0)) SWIG_fail;
6657
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6658
if (!SWIG_IsOK(res1)) {
6659
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "differentiate" "', argument " "1"" of type '" "EST_Wave &""'");
6660
}
6661
if (!argp1) {
6662
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "differentiate" "', argument " "1"" of type '" "EST_Wave &""'");
6663
}
6664
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6665
differentiate(*arg1);
6666
resultobj = SWIG_Py_Void();
6667
return resultobj;
6668
fail:
6669
return NULL;
6670
}
6671
6672
6673
SWIGINTERN PyObject *_wrap_reverse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6674
PyObject *resultobj = 0;
6675
EST_Wave *arg1 = 0 ;
6676
void *argp1 = 0 ;
6677
int res1 = 0 ;
6678
PyObject * obj0 = 0 ;
6679
6680
if (!PyArg_ParseTuple(args,(char *)"O:reverse",&obj0)) SWIG_fail;
6681
res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_EST_Wave, 0 );
6682
if (!SWIG_IsOK(res1)) {
6683
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "reverse" "', argument " "1"" of type '" "EST_Wave &""'");
6684
}
6685
if (!argp1) {
6686
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "reverse" "', argument " "1"" of type '" "EST_Wave &""'");
6687
}
6688
arg1 = reinterpret_cast< EST_Wave * >(argp1);
6689
reverse(*arg1);
6690
resultobj = SWIG_Py_Void();
6691
return resultobj;
6692
fail:
6693
return NULL;
6694
}
6695
6696
6697
static PyMethodDef SwigMethods[] = {
6698
{ (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
6699
{ (char *)"EST_Wave_default_sample_rate_get", _wrap_EST_Wave_default_sample_rate_get, METH_VARARGS, NULL},
6700
{ (char *)"new_EST_Wave", _wrap_new_EST_Wave, METH_VARARGS, NULL},
6701
{ (char *)"delete_EST_Wave", _wrap_delete_EST_Wave, METH_VARARGS, NULL},
6702
{ (char *)"EST_Wave_a", _wrap_EST_Wave_a, METH_VARARGS, NULL},
6703
{ (char *)"EST_Wave_a_safe", _wrap_EST_Wave_a_safe, METH_VARARGS, NULL},
6704
{ (char *)"EST_Wave_set_a", _wrap_EST_Wave_set_a, METH_VARARGS, NULL},
6705
{ (char *)"EST_Wave_t", _wrap_EST_Wave_t, METH_VARARGS, NULL},
6706
{ (char *)"EST_Wave_num_samples", _wrap_EST_Wave_num_samples, METH_VARARGS, NULL},
6707
{ (char *)"EST_Wave_num_channels", _wrap_EST_Wave_num_channels, METH_VARARGS, NULL},
6708
{ (char *)"EST_Wave_sample_rate", _wrap_EST_Wave_sample_rate, METH_VARARGS, NULL},
6709
{ (char *)"EST_Wave_set_sample_rate", _wrap_EST_Wave_set_sample_rate, METH_VARARGS, NULL},
6710
{ (char *)"EST_Wave_length", _wrap_EST_Wave_length, METH_VARARGS, NULL},
6711
{ (char *)"EST_Wave_end", _wrap_EST_Wave_end, METH_VARARGS, NULL},
6712
{ (char *)"EST_Wave_have_left_context", _wrap_EST_Wave_have_left_context, METH_VARARGS, NULL},
6713
{ (char *)"EST_Wave_sample_type", _wrap_EST_Wave_sample_type, METH_VARARGS, NULL},
6714
{ (char *)"EST_Wave_set_sample_type", _wrap_EST_Wave_set_sample_type, METH_VARARGS, NULL},
6715
{ (char *)"EST_Wave_file_type", _wrap_EST_Wave_file_type, METH_VARARGS, NULL},
6716
{ (char *)"EST_Wave_set_file_type", _wrap_EST_Wave_set_file_type, METH_VARARGS, NULL},
6717
{ (char *)"EST_Wave_name", _wrap_EST_Wave_name, METH_VARARGS, NULL},
6718
{ (char *)"EST_Wave_set_name", _wrap_EST_Wave_set_name, METH_VARARGS, NULL},
6719
{ (char *)"EST_Wave_resize", _wrap_EST_Wave_resize, METH_VARARGS, NULL},
6720
{ (char *)"EST_Wave_resample", _wrap_EST_Wave_resample, METH_VARARGS, NULL},
6721
{ (char *)"EST_Wave_rescale", _wrap_EST_Wave_rescale, METH_VARARGS, NULL},
6722
{ (char *)"EST_Wave_clear", _wrap_EST_Wave_clear, METH_VARARGS, NULL},
6723
{ (char *)"EST_Wave_copy", _wrap_EST_Wave_copy, METH_VARARGS, NULL},
6724
{ (char *)"EST_Wave_fill", _wrap_EST_Wave_fill, METH_VARARGS, NULL},
6725
{ (char *)"EST_Wave_empty", _wrap_EST_Wave_empty, METH_VARARGS, NULL},
6726
{ (char *)"EST_Wave_load", _wrap_EST_Wave_load, METH_VARARGS, NULL},
6727
{ (char *)"EST_Wave_load_file", _wrap_EST_Wave_load_file, METH_VARARGS, NULL},
6728
{ (char *)"EST_Wave_save", _wrap_EST_Wave_save, METH_VARARGS, NULL},
6729
{ (char *)"EST_Wave_save_file", _wrap_EST_Wave_save_file, METH_VARARGS, NULL},
6730
{ (char *)"EST_Wave_integrity", _wrap_EST_Wave_integrity, METH_VARARGS, NULL},
6731
{ (char *)"EST_Wave_info", _wrap_EST_Wave_info, METH_VARARGS, NULL},
6732
{ (char *)"EST_Wave_play", _wrap_EST_Wave_play, METH_VARARGS, NULL},
6733
{ (char *)"EST_Wave_swigregister", EST_Wave_swigregister, METH_VARARGS, NULL},
6734
{ (char *)"wave_extract_channel", _wrap_wave_extract_channel, METH_VARARGS, NULL},
6735
{ (char *)"wave_combine_channels", _wrap_wave_combine_channels, METH_VARARGS, NULL},
6736
{ (char *)"wave_subwave", _wrap_wave_subwave, METH_VARARGS, NULL},
6737
{ (char *)"wave_divide", _wrap_wave_divide, METH_VARARGS, NULL},
6738
{ (char *)"wave_extract", _wrap_wave_extract, METH_VARARGS, NULL},
6739
{ (char *)"add_waves", _wrap_add_waves, METH_VARARGS, NULL},
6740
{ (char *)"difference", _wrap_difference, METH_VARARGS, NULL},
6741
{ (char *)"rms_error", _wrap_rms_error, METH_VARARGS, NULL},
6742
{ (char *)"abs_error", _wrap_abs_error, METH_VARARGS, NULL},
6743
{ (char *)"correlation", _wrap_correlation, METH_VARARGS, NULL},
6744
{ (char *)"error", _wrap_error, METH_VARARGS, NULL},
6745
{ (char *)"absolute", _wrap_absolute, METH_VARARGS, NULL},
6746
{ (char *)"wave_info", _wrap_wave_info, METH_VARARGS, NULL},
6747
{ (char *)"invert", _wrap_invert, METH_VARARGS, NULL},
6748
{ (char *)"differentiate", _wrap_differentiate, METH_VARARGS, NULL},
6749
{ (char *)"reverse", _wrap_reverse, METH_VARARGS, NULL},
6750
{ NULL, NULL, 0, NULL }
6751
};
6752
6753
6754
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
6755
6756
static swig_type_info _swigt__p_EST_FVector = {"_p_EST_FVector", "EST_FVector *", 0, 0, (void*)0, 0};
6757
static swig_type_info _swigt__p_EST_Item = {"_p_EST_Item", "EST_Item *", 0, 0, (void*)0, 0};
6758
static swig_type_info _swigt__p_EST_Relation = {"_p_EST_Relation", "EST_Relation *", 0, 0, (void*)0, 0};
6759
static swig_type_info _swigt__p_EST_Track = {"_p_EST_Track", "EST_Track *", 0, 0, (void*)0, 0};
6760
static swig_type_info _swigt__p_EST_Wave = {"_p_EST_Wave", "EST_Wave *", 0, 0, (void*)0, 0};
6761
static swig_type_info _swigt__p_EST_WaveList = {"_p_EST_WaveList", "EST_WaveList *", 0, 0, (void*)0, 0};
6762
static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
6763
static swig_type_info _swigt__p_short = {"_p_short", "short *", 0, 0, (void*)0, 0};
6764
6765
static swig_type_info *swig_type_initial[] = {
6766
&_swigt__p_EST_FVector,
6767
&_swigt__p_EST_Item,
6768
&_swigt__p_EST_Relation,
6769
&_swigt__p_EST_Track,
6770
&_swigt__p_EST_Wave,
6771
&_swigt__p_EST_WaveList,
6772
&_swigt__p_char,
6773
&_swigt__p_short,
6774
};
6775
6776
static swig_cast_info _swigc__p_EST_FVector[] = { {&_swigt__p_EST_FVector, 0, 0, 0},{0, 0, 0, 0}};
6777
static swig_cast_info _swigc__p_EST_Item[] = { {&_swigt__p_EST_Item, 0, 0, 0},{0, 0, 0, 0}};
6778
static swig_cast_info _swigc__p_EST_Relation[] = { {&_swigt__p_EST_Relation, 0, 0, 0},{0, 0, 0, 0}};
6779
static swig_cast_info _swigc__p_EST_Track[] = { {&_swigt__p_EST_Track, 0, 0, 0},{0, 0, 0, 0}};
6780
static swig_cast_info _swigc__p_EST_Wave[] = { {&_swigt__p_EST_Wave, 0, 0, 0},{0, 0, 0, 0}};
6781
static swig_cast_info _swigc__p_EST_WaveList[] = { {&_swigt__p_EST_WaveList, 0, 0, 0},{0, 0, 0, 0}};
6782
static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
6783
static swig_cast_info _swigc__p_short[] = { {&_swigt__p_short, 0, 0, 0},{0, 0, 0, 0}};
6784
6785
static swig_cast_info *swig_cast_initial[] = {
6786
_swigc__p_EST_FVector,
6787
_swigc__p_EST_Item,
6788
_swigc__p_EST_Relation,
6789
_swigc__p_EST_Track,
6790
_swigc__p_EST_Wave,
6791
_swigc__p_EST_WaveList,
6792
_swigc__p_char,
6793
_swigc__p_short,
6794
};
6795
6796
6797
/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
6798
6799
static swig_const_info swig_const_table[] = {
6800
{0, 0, 0, 0.0, 0, 0}};
6801
6802
#ifdef __cplusplus
6803
}
6804
#endif
6805
/* -----------------------------------------------------------------------------
6806
* Type initialization:
6807
* This problem is tough by the requirement that no dynamic
6808
* memory is used. Also, since swig_type_info structures store pointers to
6809
* swig_cast_info structures and swig_cast_info structures store pointers back
6810
* to swig_type_info structures, we need some lookup code at initialization.
6811
* The idea is that swig generates all the structures that are needed.
6812
* The runtime then collects these partially filled structures.
6813
* The SWIG_InitializeModule function takes these initial arrays out of
6814
* swig_module, and does all the lookup, filling in the swig_module.types
6815
* array with the correct data and linking the correct swig_cast_info
6816
* structures together.
6817
*
6818
* The generated swig_type_info structures are assigned staticly to an initial
6819
* array. We just loop through that array, and handle each type individually.
6820
* First we lookup if this type has been already loaded, and if so, use the
6821
* loaded structure instead of the generated one. Then we have to fill in the
6822
* cast linked list. The cast data is initially stored in something like a
6823
* two-dimensional array. Each row corresponds to a type (there are the same
6824
* number of rows as there are in the swig_type_initial array). Each entry in
6825
* a column is one of the swig_cast_info structures for that type.
6826
* The cast_initial array is actually an array of arrays, because each row has
6827
* a variable number of columns. So to actually build the cast linked list,
6828
* we find the array of casts associated with the type, and loop through it
6829
* adding the casts to the list. The one last trick we need to do is making
6830
* sure the type pointer in the swig_cast_info struct is correct.
6831
*
6832
* First off, we lookup the cast->type name to see if it is already loaded.
6833
* There are three cases to handle:
6834
* 1) If the cast->type has already been loaded AND the type we are adding
6835
* casting info to has not been loaded (it is in this module), THEN we
6836
* replace the cast->type pointer with the type pointer that has already
6837
* been loaded.
6838
* 2) If BOTH types (the one we are adding casting info to, and the
6839
* cast->type) are loaded, THEN the cast info has already been loaded by
6840
* the previous module so we just ignore it.
6841
* 3) Finally, if cast->type has not already been loaded, then we add that
6842
* swig_cast_info to the linked list (because the cast->type) pointer will
6843
* be correct.
6844
* ----------------------------------------------------------------------------- */
6845
6846
#ifdef __cplusplus
6847
extern "C" {
6848
#if 0
6849
} /* c-mode */
6850
#endif
6851
#endif
6852
6853
#if 0
6854
#define SWIGRUNTIME_DEBUG
6855
#endif
6856
6857
6858
SWIGRUNTIME void
6859
SWIG_InitializeModule(void *clientdata) {
6860
size_t i;
6861
swig_module_info *module_head, *iter;
6862
int found, init;
6863
6864
clientdata = clientdata;
6865
6866
/* check to see if the circular list has been setup, if not, set it up */
6867
if (swig_module.next==0) {
6868
/* Initialize the swig_module */
6869
swig_module.type_initial = swig_type_initial;
6870
swig_module.cast_initial = swig_cast_initial;
6871
swig_module.next = &swig_module;
6872
init = 1;
6873
} else {
6874
init = 0;
6875
}
6876
6877
/* Try and load any already created modules */
6878
module_head = SWIG_GetModule(clientdata);
6879
if (!module_head) {
6880
/* This is the first module loaded for this interpreter */
6881
/* so set the swig module into the interpreter */
6882
SWIG_SetModule(clientdata, &swig_module);
6883
module_head = &swig_module;
6884
} else {
6885
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
6886
found=0;
6887
iter=module_head;
6888
do {
6889
if (iter==&swig_module) {
6890
found=1;
6891
break;
6892
}
6893
iter=iter->next;
6894
} while (iter!= module_head);
6895
6896
/* if the is found in the list, then all is done and we may leave */
6897
if (found) return;
6898
/* otherwise we must add out module into the list */
6899
swig_module.next = module_head->next;
6900
module_head->next = &swig_module;
6901
}
6902
6903
/* When multiple interpeters are used, a module could have already been initialized in
6904
a different interpreter, but not yet have a pointer in this interpreter.
6905
In this case, we do not want to continue adding types... everything should be
6906
set up already */
6907
if (init == 0) return;
6908
6909
/* Now work on filling in swig_module.types */
6910
#ifdef SWIGRUNTIME_DEBUG
6911
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
6912
#endif
6913
for (i = 0; i < swig_module.size; ++i) {
6914
swig_type_info *type = 0;
6915
swig_type_info *ret;
6916
swig_cast_info *cast;
6917
6918
#ifdef SWIGRUNTIME_DEBUG
6919
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6920
#endif
6921
6922
/* if there is another module already loaded */
6923
if (swig_module.next != &swig_module) {
6924
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
6925
}
6926
if (type) {
6927
/* Overwrite clientdata field */
6928
#ifdef SWIGRUNTIME_DEBUG
6929
printf("SWIG_InitializeModule: found type %s\n", type->name);
6930
#endif
6931
if (swig_module.type_initial[i]->clientdata) {
6932
type->clientdata = swig_module.type_initial[i]->clientdata;
6933
#ifdef SWIGRUNTIME_DEBUG
6934
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
6935
#endif
6936
}
6937
} else {
6938
type = swig_module.type_initial[i];
6939
}
6940
6941
/* Insert casting types */
6942
cast = swig_module.cast_initial[i];
6943
while (cast->type) {
6944
/* Don't need to add information already in the list */
6945
ret = 0;
6946
#ifdef SWIGRUNTIME_DEBUG
6947
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
6948
#endif
6949
if (swig_module.next != &swig_module) {
6950
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
6951
#ifdef SWIGRUNTIME_DEBUG
6952
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
6953
#endif
6954
}
6955
if (ret) {
6956
if (type == swig_module.type_initial[i]) {
6957
#ifdef SWIGRUNTIME_DEBUG
6958
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
6959
#endif
6960
cast->type = ret;
6961
ret = 0;
6962
} else {
6963
/* Check for casting already in the list */
6964
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
6965
#ifdef SWIGRUNTIME_DEBUG
6966
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
6967
#endif
6968
if (!ocast) ret = 0;
6969
}
6970
}
6971
6972
if (!ret) {
6973
#ifdef SWIGRUNTIME_DEBUG
6974
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
6975
#endif
6976
if (type->cast) {
6977
type->cast->prev = cast;
6978
cast->next = type->cast;
6979
}
6980
type->cast = cast;
6981
}
6982
cast++;
6983
}
6984
/* Set entry in modules->types array equal to the type */
6985
swig_module.types[i] = type;
6986
}
6987
swig_module.types[i] = 0;
6988
6989
#ifdef SWIGRUNTIME_DEBUG
6990
printf("**** SWIG_InitializeModule: Cast List ******\n");
6991
for (i = 0; i < swig_module.size; ++i) {
6992
int j = 0;
6993
swig_cast_info *cast = swig_module.cast_initial[i];
6994
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
6995
while (cast->type) {
6996
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
6997
cast++;
6998
++j;
6999
}
7000
printf("---- Total casts: %d\n",j);
7001
}
7002
printf("**** SWIG_InitializeModule: Cast List ******\n");
7003
#endif
7004
}
7005
7006
/* This function will propagate the clientdata field of type to
7007
* any new swig_type_info structures that have been added into the list
7008
* of equivalent types. It is like calling
7009
* SWIG_TypeClientData(type, clientdata) a second time.
7010
*/
7011
SWIGRUNTIME void
7012
SWIG_PropagateClientData(void) {
7013
size_t i;
7014
swig_cast_info *equiv;
7015
static int init_run = 0;
7016
7017
if (init_run) return;
7018
init_run = 1;
7019
7020
for (i = 0; i < swig_module.size; i++) {
7021
if (swig_module.types[i]->clientdata) {
7022
equiv = swig_module.types[i]->cast;
7023
while (equiv) {
7024
if (!equiv->converter) {
7025
if (equiv->type && !equiv->type->clientdata)
7026
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
7027
}
7028
equiv = equiv->next;
7029
}
7030
}
7031
}
7032
}
7033
7034
#ifdef __cplusplus
7035
#if 0
7036
{
7037
/* c-mode */
7038
#endif
7039
}
7040
#endif
7041
7042
7043
7044
#ifdef __cplusplus
7045
extern "C" {
7046
#endif
7047
7048
/* Python-specific SWIG API */
7049
#define SWIG_newvarlink() SWIG_Python_newvarlink()
7050
#define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
7051
#define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
7052
7053
/* -----------------------------------------------------------------------------
7054
* global variable support code.
7055
* ----------------------------------------------------------------------------- */
7056
7057
typedef struct swig_globalvar {
7058
char *name; /* Name of global variable */
7059
PyObject *(*get_attr)(void); /* Return the current value */
7060
int (*set_attr)(PyObject *); /* Set the value */
7061
struct swig_globalvar *next;
7062
} swig_globalvar;
7063
7064
typedef struct swig_varlinkobject {
7065
PyObject_HEAD
7066
swig_globalvar *vars;
7067
} swig_varlinkobject;
7068
7069
SWIGINTERN PyObject *
7070
swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
7071
#if PY_VERSION_HEX >= 0x03000000
7072
return PyUnicode_InternFromString("<Swig global variables>");
7073
#else
7074
return PyString_FromString("<Swig global variables>");
7075
#endif
7076
}
7077
7078
SWIGINTERN PyObject *
7079
swig_varlink_str(swig_varlinkobject *v) {
7080
#if PY_VERSION_HEX >= 0x03000000
7081
PyObject *str = PyUnicode_InternFromString("(");
7082
PyObject *tail;
7083
PyObject *joined;
7084
swig_globalvar *var;
7085
for (var = v->vars; var; var=var->next) {
7086
tail = PyUnicode_FromString(var->name);
7087
joined = PyUnicode_Concat(str, tail);
7088
Py_DecRef(str);
7089
Py_DecRef(tail);
7090
str = joined;
7091
if (var->next) {
7092
tail = PyUnicode_InternFromString(", ");
7093
joined = PyUnicode_Concat(str, tail);
7094
Py_DecRef(str);
7095
Py_DecRef(tail);
7096
str = joined;
7097
}
7098
}
7099
tail = PyUnicode_InternFromString(")");
7100
joined = PyUnicode_Concat(str, tail);
7101
Py_DecRef(str);
7102
Py_DecRef(tail);
7103
str = joined;
7104
#else
7105
PyObject *str = PyString_FromString("(");
7106
swig_globalvar *var;
7107
for (var = v->vars; var; var=var->next) {
7108
PyString_ConcatAndDel(&str,PyString_FromString(var->name));
7109
if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
7110
}
7111
PyString_ConcatAndDel(&str,PyString_FromString(")"));
7112
#endif
7113
return str;
7114
}
7115
7116
SWIGINTERN int
7117
swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
7118
char *tmp;
7119
PyObject *str = swig_varlink_str(v);
7120
fprintf(fp,"Swig global variables ");
7121
fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
7122
SWIG_Python_str_DelForPy3(tmp);
7123
Py_DECREF(str);
7124
return 0;
7125
}
7126
7127
SWIGINTERN void
7128
swig_varlink_dealloc(swig_varlinkobject *v) {
7129
swig_globalvar *var = v->vars;
7130
while (var) {
7131
swig_globalvar *n = var->next;
7132
free(var->name);
7133
free(var);
7134
var = n;
7135
}
7136
}
7137
7138
SWIGINTERN PyObject *
7139
swig_varlink_getattr(swig_varlinkobject *v, char *n) {
7140
PyObject *res = NULL;
7141
swig_globalvar *var = v->vars;
7142
while (var) {
7143
if (strcmp(var->name,n) == 0) {
7144
res = (*var->get_attr)();
7145
break;
7146
}
7147
var = var->next;
7148
}
7149
if (res == NULL && !PyErr_Occurred()) {
7150
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7151
}
7152
return res;
7153
}
7154
7155
SWIGINTERN int
7156
swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
7157
int res = 1;
7158
swig_globalvar *var = v->vars;
7159
while (var) {
7160
if (strcmp(var->name,n) == 0) {
7161
res = (*var->set_attr)(p);
7162
break;
7163
}
7164
var = var->next;
7165
}
7166
if (res == 1 && !PyErr_Occurred()) {
7167
PyErr_SetString(PyExc_NameError,"Unknown C global variable");
7168
}
7169
return res;
7170
}
7171
7172
SWIGINTERN PyTypeObject*
7173
swig_varlink_type(void) {
7174
static char varlink__doc__[] = "Swig var link object";
7175
static PyTypeObject varlink_type;
7176
static int type_init = 0;
7177
if (!type_init) {
7178
const PyTypeObject tmp
7179
= {
7180
/* PyObject header changed in Python 3 */
7181
#if PY_VERSION_HEX >= 0x03000000
7182
PyVarObject_HEAD_INIT(&PyType_Type, 0)
7183
#else
7184
PyObject_HEAD_INIT(NULL)
7185
0, /* Number of items in variable part (ob_size) */
7186
#endif
7187
(char *)"swigvarlink", /* Type name (tp_name) */
7188
sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
7189
0, /* Itemsize (tp_itemsize) */
7190
(destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
7191
(printfunc) swig_varlink_print, /* Print (tp_print) */
7192
(getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
7193
(setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
7194
0, /* tp_compare */
7195
(reprfunc) swig_varlink_repr, /* tp_repr */
7196
0, /* tp_as_number */
7197
0, /* tp_as_sequence */
7198
0, /* tp_as_mapping */
7199
0, /* tp_hash */
7200
0, /* tp_call */
7201
(reprfunc) swig_varlink_str, /* tp_str */
7202
0, /* tp_getattro */
7203
0, /* tp_setattro */
7204
0, /* tp_as_buffer */
7205
0, /* tp_flags */
7206
varlink__doc__, /* tp_doc */
7207
0, /* tp_traverse */
7208
0, /* tp_clear */
7209
0, /* tp_richcompare */
7210
0, /* tp_weaklistoffset */
7211
#if PY_VERSION_HEX >= 0x02020000
7212
0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
7213
#endif
7214
#if PY_VERSION_HEX >= 0x02030000
7215
0, /* tp_del */
7216
#endif
7217
#ifdef COUNT_ALLOCS
7218
0,0,0,0 /* tp_alloc -> tp_next */
7219
#endif
7220
};
7221
varlink_type = tmp;
7222
/* for Python 3 we already assigned ob_type in PyVarObject_HEAD_INIT() */
7223
#if PY_VERSION_HEX < 0x03000000
7224
varlink_type.ob_type = &PyType_Type;
7225
#endif
7226
type_init = 1;
7227
}
7228
return &varlink_type;
7229
}
7230
7231
/* Create a variable linking object for use later */
7232
SWIGINTERN PyObject *
7233
SWIG_Python_newvarlink(void) {
7234
swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
7235
if (result) {
7236
result->vars = 0;
7237
}
7238
return ((PyObject*) result);
7239
}
7240
7241
SWIGINTERN void
7242
SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
7243
swig_varlinkobject *v = (swig_varlinkobject *) p;
7244
swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
7245
if (gv) {
7246
size_t size = strlen(name)+1;
7247
gv->name = (char *)malloc(size);
7248
if (gv->name) {
7249
strncpy(gv->name,name,size);
7250
gv->get_attr = get_attr;
7251
gv->set_attr = set_attr;
7252
gv->next = v->vars;
7253
}
7254
}
7255
v->vars = gv;
7256
}
7257
7258
SWIGINTERN PyObject *
7259
SWIG_globals(void) {
7260
static PyObject *_SWIG_globals = 0;
7261
if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
7262
return _SWIG_globals;
7263
}
7264
7265
/* -----------------------------------------------------------------------------
7266
* constants/methods manipulation
7267
* ----------------------------------------------------------------------------- */
7268
7269
/* Install Constants */
7270
SWIGINTERN void
7271
SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
7272
PyObject *obj = 0;
7273
size_t i;
7274
for (i = 0; constants[i].type; ++i) {
7275
switch(constants[i].type) {
7276
case SWIG_PY_POINTER:
7277
obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
7278
break;
7279
case SWIG_PY_BINARY:
7280
obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
7281
break;
7282
default:
7283
obj = 0;
7284
break;
7285
}
7286
if (obj) {
7287
PyDict_SetItemString(d, constants[i].name, obj);
7288
Py_DECREF(obj);
7289
}
7290
}
7291
}
7292
7293
/* -----------------------------------------------------------------------------*/
7294
/* Fix SwigMethods to carry the callback ptrs when needed */
7295
/* -----------------------------------------------------------------------------*/
7296
7297
SWIGINTERN void
7298
SWIG_Python_FixMethods(PyMethodDef *methods,
7299
swig_const_info *const_table,
7300
swig_type_info **types,
7301
swig_type_info **types_initial) {
7302
size_t i;
7303
for (i = 0; methods[i].ml_name; ++i) {
7304
const char *c = methods[i].ml_doc;
7305
if (c && (c = strstr(c, "swig_ptr: "))) {
7306
int j;
7307
swig_const_info *ci = 0;
7308
const char *name = c + 10;
7309
for (j = 0; const_table[j].type; ++j) {
7310
if (strncmp(const_table[j].name, name,
7311
strlen(const_table[j].name)) == 0) {
7312
ci = &(const_table[j]);
7313
break;
7314
}
7315
}
7316
if (ci) {
7317
size_t shift = (ci->ptype) - types;
7318
swig_type_info *ty = types_initial[shift];
7319
size_t ldoc = (c - methods[i].ml_doc);
7320
size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
7321
char *ndoc = (char*)malloc(ldoc + lptr + 10);
7322
if (ndoc) {
7323
char *buff = ndoc;
7324
void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
7325
if (ptr) {
7326
strncpy(buff, methods[i].ml_doc, ldoc);
7327
buff += ldoc;
7328
strncpy(buff, "swig_ptr: ", 10);
7329
buff += 10;
7330
SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
7331
methods[i].ml_doc = ndoc;
7332
}
7333
}
7334
}
7335
}
7336
}
7337
}
7338
7339
#ifdef __cplusplus
7340
}
7341
#endif
7342
7343
/* -----------------------------------------------------------------------------*
7344
* Partial Init method
7345
* -----------------------------------------------------------------------------*/
7346
7347
#ifdef __cplusplus
7348
extern "C"
7349
#endif
7350
7351
SWIGEXPORT
7352
#if PY_VERSION_HEX >= 0x03000000
7353
PyObject*
7354
#else
7355
void
7356
#endif
7357
SWIG_init(void) {
7358
PyObject *m, *d;
7359
#if PY_VERSION_HEX >= 0x03000000
7360
static struct PyModuleDef SWIG_module = {
7361
PyModuleDef_HEAD_INIT,
7362
(char *) SWIG_name,
7363
NULL,
7364
-1,
7365
SwigMethods,
7366
NULL,
7367
NULL,
7368
NULL,
7369
NULL
7370
};
7371
#endif
7372
7373
/* Fix SwigMethods to carry the callback ptrs when needed */
7374
SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
7375
7376
#if PY_VERSION_HEX >= 0x03000000
7377
m = PyModule_Create(&SWIG_module);
7378
#else
7379
m = Py_InitModule((char *) SWIG_name, SwigMethods);
7380
#endif
7381
d = PyModule_GetDict(m);
7382
7383
SWIG_InitializeModule(0);
7384
SWIG_InstallConstants(d,swig_const_table);
7385
7386
7387
SWIG_Python_SetConstant(d, "read_ok",SWIG_From_int(static_cast< int >(read_ok)));
7388
SWIG_Python_SetConstant(d, "read_format_error",SWIG_From_int(static_cast< int >(read_format_error)));
7389
SWIG_Python_SetConstant(d, "read_not_found_error",SWIG_From_int(static_cast< int >(read_not_found_error)));
7390
SWIG_Python_SetConstant(d, "read_error",SWIG_From_int(static_cast< int >(read_error)));
7391
SWIG_Python_SetConstant(d, "write_ok",SWIG_From_int(static_cast< int >(write_ok)));
7392
SWIG_Python_SetConstant(d, "write_fail",SWIG_From_int(static_cast< int >(write_fail)));
7393
SWIG_Python_SetConstant(d, "write_error",SWIG_From_int(static_cast< int >(write_error)));
7394
SWIG_Python_SetConstant(d, "write_partial",SWIG_From_int(static_cast< int >(write_partial)));
7395
SWIG_Python_SetConstant(d, "connect_ok",SWIG_From_int(static_cast< int >(connect_ok)));
7396
SWIG_Python_SetConstant(d, "connect_not_found_error",SWIG_From_int(static_cast< int >(connect_not_found_error)));
7397
SWIG_Python_SetConstant(d, "connect_not_allowed_error",SWIG_From_int(static_cast< int >(connect_not_allowed_error)));
7398
SWIG_Python_SetConstant(d, "connect_system_error",SWIG_From_int(static_cast< int >(connect_system_error)));
7399
SWIG_Python_SetConstant(d, "connect_error",SWIG_From_int(static_cast< int >(connect_error)));
7400
#if PY_VERSION_HEX >= 0x03000000
7401
return m;
7402
#else
7403
return;
7404
#endif
7405
}
7406
Loggerhead is a web-based interface for Breezy
Version: 2.0.1