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