Line data Source code
1 : /* ----------------------------------------------------------------------------
2 : * This file was automatically generated by SWIG (http://www.swig.org).
3 : * Version 3.0.10
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 :
12 : #ifndef SWIGPYTHON
13 : #define SWIGPYTHON
14 : #endif
15 :
16 : #define SWIG_PYTHON_THREADS
17 : #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
18 :
19 : /* -----------------------------------------------------------------------------
20 : * This section contains generic SWIG labels for method/variable
21 : * declarations/attributes, and other compiler dependent labels.
22 : * ----------------------------------------------------------------------------- */
23 :
24 : /* template workaround for compilers that cannot correctly implement the C++ standard */
25 : #ifndef SWIGTEMPLATEDISAMBIGUATOR
26 : # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
27 : # define SWIGTEMPLATEDISAMBIGUATOR template
28 : # elif defined(__HP_aCC)
29 : /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
30 : /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
31 : # define SWIGTEMPLATEDISAMBIGUATOR template
32 : # else
33 : # define SWIGTEMPLATEDISAMBIGUATOR
34 : # endif
35 : #endif
36 :
37 : /* inline attribute */
38 : #ifndef SWIGINLINE
39 : # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
40 : # define SWIGINLINE inline
41 : # else
42 : # define SWIGINLINE
43 : # endif
44 : #endif
45 :
46 : /* attribute recognised by some compilers to avoid 'unused' warnings */
47 : #ifndef SWIGUNUSED
48 : # if defined(__GNUC__)
49 : # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
50 : # define SWIGUNUSED __attribute__ ((__unused__))
51 : # else
52 : # define SWIGUNUSED
53 : # endif
54 : # elif defined(__ICC)
55 : # define SWIGUNUSED __attribute__ ((__unused__))
56 : # else
57 : # define SWIGUNUSED
58 : # endif
59 : #endif
60 :
61 : #ifndef SWIG_MSC_UNSUPPRESS_4505
62 : # if defined(_MSC_VER)
63 : # pragma warning(disable : 4505) /* unreferenced local function has been removed */
64 : # endif
65 : #endif
66 :
67 : #ifndef SWIGUNUSEDPARM
68 : # ifdef __cplusplus
69 : # define SWIGUNUSEDPARM(p)
70 : # else
71 : # define SWIGUNUSEDPARM(p) p SWIGUNUSED
72 : # endif
73 : #endif
74 :
75 : /* internal SWIG method */
76 : #ifndef SWIGINTERN
77 : # define SWIGINTERN static SWIGUNUSED
78 : #endif
79 :
80 : /* internal inline SWIG method */
81 : #ifndef SWIGINTERNINLINE
82 : # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
83 : #endif
84 :
85 : /* exporting methods */
86 : #if defined(__GNUC__)
87 : # if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
88 : # ifndef GCC_HASCLASSVISIBILITY
89 : # define GCC_HASCLASSVISIBILITY
90 : # endif
91 : # endif
92 : #endif
93 :
94 : #ifndef SWIGEXPORT
95 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
96 : # if defined(STATIC_LINKED)
97 : # define SWIGEXPORT
98 : # else
99 : # define SWIGEXPORT __declspec(dllexport)
100 : # endif
101 : # else
102 : # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
103 : # define SWIGEXPORT __attribute__ ((visibility("default")))
104 : # else
105 : # define SWIGEXPORT
106 : # endif
107 : # endif
108 : #endif
109 :
110 : /* calling conventions for Windows */
111 : #ifndef SWIGSTDCALL
112 : # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
113 : # define SWIGSTDCALL __stdcall
114 : # else
115 : # define SWIGSTDCALL
116 : # endif
117 : #endif
118 :
119 : /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
120 : #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
121 : # define _CRT_SECURE_NO_DEPRECATE
122 : #endif
123 :
124 : /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
125 : #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
126 : # define _SCL_SECURE_NO_DEPRECATE
127 : #endif
128 :
129 : /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
130 : #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
131 : # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
132 : #endif
133 :
134 : /* Intel's compiler complains if a variable which was never initialised is
135 : * cast to void, which is a common idiom which we use to indicate that we
136 : * are aware a variable isn't used. So we just silence that warning.
137 : * See: https://github.com/swig/swig/issues/192 for more discussion.
138 : */
139 : #ifdef __INTEL_COMPILER
140 : # pragma warning disable 592
141 : #endif
142 :
143 :
144 : #if defined(_DEBUG) && defined(SWIG_PYTHON_INTERPRETER_NO_DEBUG)
145 : /* Use debug wrappers with the Python release dll */
146 : # undef _DEBUG
147 : # include <Python.h>
148 : # define _DEBUG
149 : #else
150 : # include <Python.h>
151 : #endif
152 :
153 : /* -----------------------------------------------------------------------------
154 : * swigrun.swg
155 : *
156 : * This file contains generic C API SWIG runtime support for pointer
157 : * type checking.
158 : * ----------------------------------------------------------------------------- */
159 :
160 : /* This should only be incremented when either the layout of swig_type_info changes,
161 : or for whatever reason, the runtime changes incompatibly */
162 : #define SWIG_RUNTIME_VERSION "4"
163 :
164 : /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
165 : #ifdef SWIG_TYPE_TABLE
166 : # define SWIG_QUOTE_STRING(x) #x
167 : # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
168 : # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
169 : #else
170 : # define SWIG_TYPE_TABLE_NAME
171 : #endif
172 :
173 : /*
174 : You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
175 : creating a static or dynamic library from the SWIG runtime code.
176 : In 99.9% of the cases, SWIG just needs to declare them as 'static'.
177 :
178 : But only do this if strictly necessary, ie, if you have problems
179 : with your compiler or suchlike.
180 : */
181 :
182 : #ifndef SWIGRUNTIME
183 : # define SWIGRUNTIME SWIGINTERN
184 : #endif
185 :
186 : #ifndef SWIGRUNTIMEINLINE
187 : # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
188 : #endif
189 :
190 : /* Generic buffer size */
191 : #ifndef SWIG_BUFFER_SIZE
192 : # define SWIG_BUFFER_SIZE 1024
193 : #endif
194 :
195 : /* Flags for pointer conversions */
196 : #define SWIG_POINTER_DISOWN 0x1
197 : #define SWIG_CAST_NEW_MEMORY 0x2
198 :
199 : /* Flags for new pointer objects */
200 : #define SWIG_POINTER_OWN 0x1
201 :
202 :
203 : /*
204 : Flags/methods for returning states.
205 :
206 : The SWIG conversion methods, as ConvertPtr, return an integer
207 : that tells if the conversion was successful or not. And if not,
208 : an error code can be returned (see swigerrors.swg for the codes).
209 :
210 : Use the following macros/flags to set or process the returning
211 : states.
212 :
213 : In old versions of SWIG, code such as the following was usually written:
214 :
215 : if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
216 : // success code
217 : } else {
218 : //fail code
219 : }
220 :
221 : Now you can be more explicit:
222 :
223 : int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
224 : if (SWIG_IsOK(res)) {
225 : // success code
226 : } else {
227 : // fail code
228 : }
229 :
230 : which is the same really, but now you can also do
231 :
232 : Type *ptr;
233 : int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
234 : if (SWIG_IsOK(res)) {
235 : // success code
236 : if (SWIG_IsNewObj(res) {
237 : ...
238 : delete *ptr;
239 : } else {
240 : ...
241 : }
242 : } else {
243 : // fail code
244 : }
245 :
246 : I.e., now SWIG_ConvertPtr can return new objects and you can
247 : identify the case and take care of the deallocation. Of course that
248 : also requires SWIG_ConvertPtr to return new result values, such as
249 :
250 : int SWIG_ConvertPtr(obj, ptr,...) {
251 : if (<obj is ok>) {
252 : if (<need new object>) {
253 : *ptr = <ptr to new allocated object>;
254 : return SWIG_NEWOBJ;
255 : } else {
256 : *ptr = <ptr to old object>;
257 : return SWIG_OLDOBJ;
258 : }
259 : } else {
260 : return SWIG_BADOBJ;
261 : }
262 : }
263 :
264 : Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
265 : more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
266 : SWIG errors code.
267 :
268 : Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
269 : allows to return the 'cast rank', for example, if you have this
270 :
271 : int food(double)
272 : int fooi(int);
273 :
274 : and you call
275 :
276 : food(1) // cast rank '1' (1 -> 1.0)
277 : fooi(1) // cast rank '0'
278 :
279 : just use the SWIG_AddCast()/SWIG_CheckState()
280 : */
281 :
282 : #define SWIG_OK (0)
283 : #define SWIG_ERROR (-1)
284 : #define SWIG_IsOK(r) (r >= 0)
285 : #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
286 :
287 : /* The CastRankLimit says how many bits are used for the cast rank */
288 : #define SWIG_CASTRANKLIMIT (1 << 8)
289 : /* The NewMask denotes the object was created (using new/malloc) */
290 : #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
291 : /* The TmpMask is for in/out typemaps that use temporal objects */
292 : #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
293 : /* Simple returning values */
294 : #define SWIG_BADOBJ (SWIG_ERROR)
295 : #define SWIG_OLDOBJ (SWIG_OK)
296 : #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
297 : #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
298 : /* Check, add and del mask methods */
299 : #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
300 : #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
301 : #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
302 : #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
303 : #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
304 : #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
305 :
306 : /* Cast-Rank Mode */
307 : #if defined(SWIG_CASTRANK_MODE)
308 : # ifndef SWIG_TypeRank
309 : # define SWIG_TypeRank unsigned long
310 : # endif
311 : # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
312 : # define SWIG_MAXCASTRANK (2)
313 : # endif
314 : # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
315 : # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
316 : SWIGINTERNINLINE int SWIG_AddCast(int r) {
317 : return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
318 : }
319 : SWIGINTERNINLINE int SWIG_CheckState(int r) {
320 : return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
321 : }
322 : #else /* no cast-rank mode */
323 : # define SWIG_AddCast(r) (r)
324 : # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
325 : #endif
326 :
327 :
328 : #include <string.h>
329 :
330 : #ifdef __cplusplus
331 : extern "C" {
332 : #endif
333 :
334 : typedef void *(*swig_converter_func)(void *, int *);
335 : typedef struct swig_type_info *(*swig_dycast_func)(void **);
336 :
337 : /* Structure to store information on one type */
338 : typedef struct swig_type_info {
339 : const char *name; /* mangled name of this type */
340 : const char *str; /* human readable name of this type */
341 : swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
342 : struct swig_cast_info *cast; /* linked list of types that can cast into this type */
343 : void *clientdata; /* language specific type data */
344 : int owndata; /* flag if the structure owns the clientdata */
345 : } swig_type_info;
346 :
347 : /* Structure to store a type and conversion function used for casting */
348 : typedef struct swig_cast_info {
349 : swig_type_info *type; /* pointer to type that is equivalent to this type */
350 : swig_converter_func converter; /* function to cast the void pointers */
351 : struct swig_cast_info *next; /* pointer to next cast in linked list */
352 : struct swig_cast_info *prev; /* pointer to the previous cast */
353 : } swig_cast_info;
354 :
355 : /* Structure used to store module information
356 : * Each module generates one structure like this, and the runtime collects
357 : * all of these structures and stores them in a circularly linked list.*/
358 : typedef struct swig_module_info {
359 : swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
360 : size_t size; /* Number of types in this module */
361 : struct swig_module_info *next; /* Pointer to next element in circularly linked list */
362 : swig_type_info **type_initial; /* Array of initially generated type structures */
363 : swig_cast_info **cast_initial; /* Array of initially generated casting structures */
364 : void *clientdata; /* Language specific module data */
365 : } swig_module_info;
366 :
367 : /*
368 : Compare two type names skipping the space characters, therefore
369 : "char*" == "char *" and "Class<int>" == "Class<int >", etc.
370 :
371 : Return 0 when the two name types are equivalent, as in
372 : strncmp, but skipping ' '.
373 : */
374 : SWIGRUNTIME int
375 0 : SWIG_TypeNameComp(const char *f1, const char *l1,
376 : const char *f2, const char *l2) {
377 0 : for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
378 0 : while ((*f1 == ' ') && (f1 != l1)) ++f1;
379 0 : while ((*f2 == ' ') && (f2 != l2)) ++f2;
380 0 : if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
381 : }
382 0 : return (int)((l1 - f1) - (l2 - f2));
383 : }
384 :
385 : /*
386 : Check type equivalence in a name list like <name1>|<name2>|...
387 : Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 : */
389 : SWIGRUNTIME int
390 0 : SWIG_TypeCmp(const char *nb, const char *tb) {
391 0 : int equiv = 1;
392 0 : const char* te = tb + strlen(tb);
393 0 : const char* ne = nb;
394 0 : while (equiv != 0 && *ne) {
395 0 : for (nb = ne; *ne; ++ne) {
396 0 : if (*ne == '|') break;
397 : }
398 0 : equiv = SWIG_TypeNameComp(nb, ne, tb, te);
399 0 : if (*ne) ++ne;
400 : }
401 0 : return equiv;
402 : }
403 :
404 : /*
405 : Check type equivalence in a name list like <name1>|<name2>|...
406 : Return 0 if not equal, 1 if equal
407 : */
408 : SWIGRUNTIME int
409 : SWIG_TypeEquiv(const char *nb, const char *tb) {
410 0 : return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
411 : }
412 :
413 : /*
414 : Check the typename
415 : */
416 : SWIGRUNTIME swig_cast_info *
417 0 : SWIG_TypeCheck(const char *c, swig_type_info *ty) {
418 0 : if (ty) {
419 0 : swig_cast_info *iter = ty->cast;
420 0 : while (iter) {
421 0 : if (strcmp(iter->type->name, c) == 0) {
422 0 : if (iter == ty->cast)
423 : return iter;
424 : /* Move iter to the top of the linked list */
425 0 : iter->prev->next = iter->next;
426 0 : if (iter->next)
427 0 : iter->next->prev = iter->prev;
428 0 : iter->next = ty->cast;
429 0 : iter->prev = 0;
430 0 : if (ty->cast) ty->cast->prev = iter;
431 0 : ty->cast = iter;
432 0 : return iter;
433 : }
434 0 : iter = iter->next;
435 : }
436 : }
437 : return 0;
438 : }
439 :
440 : /*
441 : Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
442 : */
443 : SWIGRUNTIME swig_cast_info *
444 : SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
445 : if (ty) {
446 : swig_cast_info *iter = ty->cast;
447 : while (iter) {
448 : if (iter->type == from) {
449 : if (iter == ty->cast)
450 : return iter;
451 : /* Move iter to the top of the linked list */
452 : iter->prev->next = iter->next;
453 : if (iter->next)
454 : iter->next->prev = iter->prev;
455 : iter->next = ty->cast;
456 : iter->prev = 0;
457 : if (ty->cast) ty->cast->prev = iter;
458 : ty->cast = iter;
459 : return iter;
460 : }
461 : iter = iter->next;
462 : }
463 : }
464 : return 0;
465 : }
466 :
467 : /*
468 : Cast a pointer up an inheritance hierarchy
469 : */
470 : SWIGRUNTIMEINLINE void *
471 : SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
472 0 : return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
473 : }
474 :
475 : /*
476 : Dynamic pointer casting. Down an inheritance hierarchy
477 : */
478 : SWIGRUNTIME swig_type_info *
479 : SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
480 : swig_type_info *lastty = ty;
481 : if (!ty || !ty->dcast) return ty;
482 : while (ty && (ty->dcast)) {
483 : ty = (*ty->dcast)(ptr);
484 : if (ty) lastty = ty;
485 : }
486 : return lastty;
487 : }
488 :
489 : /*
490 : Return the name associated with this type
491 : */
492 : SWIGRUNTIMEINLINE const char *
493 : SWIG_TypeName(const swig_type_info *ty) {
494 : return ty->name;
495 : }
496 :
497 : /*
498 : Return the pretty name associated with this type,
499 : that is an unmangled type name in a form presentable to the user.
500 : */
501 : SWIGRUNTIME const char *
502 : SWIG_TypePrettyName(const swig_type_info *type) {
503 : /* The "str" field contains the equivalent pretty names of the
504 : type, separated by vertical-bar characters. We choose
505 : to print the last name, as it is often (?) the most
506 : specific. */
507 0 : if (!type) return NULL;
508 0 : if (type->str != NULL) {
509 : const char *last_name = type->str;
510 : const char *s;
511 0 : for (s = type->str; *s; s++)
512 0 : if (*s == '|') last_name = s+1;
513 : return last_name;
514 : }
515 : else
516 0 : return type->name;
517 : }
518 :
519 : /*
520 : Set the clientdata field for a type
521 : */
522 : SWIGRUNTIME void
523 810 : SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
524 810 : swig_cast_info *cast = ti->cast;
525 : /* if (ti->clientdata == clientdata) return; */
526 810 : ti->clientdata = clientdata;
527 :
528 1620 : while (cast) {
529 810 : if (!cast->converter) {
530 810 : swig_type_info *tc = cast->type;
531 810 : if (!tc->clientdata) {
532 0 : SWIG_TypeClientData(tc, clientdata);
533 : }
534 : }
535 810 : cast = cast->next;
536 : }
537 810 : }
538 : SWIGRUNTIME void
539 : SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
540 810 : SWIG_TypeClientData(ti, clientdata);
541 810 : ti->owndata = 1;
542 : }
543 :
544 : /*
545 : Search for a swig_type_info structure only by mangled name
546 : Search is a O(log #types)
547 :
548 : We start searching at module start, and finish searching when start == end.
549 : Note: if start == end at the beginning of the function, we go all the way around
550 : the circular list.
551 : */
552 : SWIGRUNTIME swig_type_info *
553 0 : SWIG_MangledTypeQueryModule(swig_module_info *start,
554 : swig_module_info *end,
555 : const char *name) {
556 0 : swig_module_info *iter = start;
557 : do {
558 0 : if (iter->size) {
559 0 : size_t l = 0;
560 0 : size_t r = iter->size - 1;
561 : do {
562 : /* since l+r >= 0, we can (>> 1) instead (/ 2) */
563 0 : size_t i = (l + r) >> 1;
564 0 : const char *iname = iter->types[i]->name;
565 0 : if (iname) {
566 0 : int compare = strcmp(name, iname);
567 0 : if (compare == 0) {
568 : return iter->types[i];
569 0 : } else if (compare < 0) {
570 0 : if (i) {
571 0 : r = i - 1;
572 : } else {
573 : break;
574 : }
575 0 : } else if (compare > 0) {
576 0 : l = i + 1;
577 : }
578 : } else {
579 : break; /* should never happen */
580 : }
581 0 : } while (l <= r);
582 : }
583 0 : iter = iter->next;
584 0 : } while (iter != end);
585 : return 0;
586 : }
587 :
588 : /*
589 : Search for a swig_type_info structure for either a mangled name or a human readable name.
590 : It first searches the mangled names of the types, which is a O(log #types)
591 : If a type is not found it then searches the human readable names, which is O(#types).
592 :
593 : We start searching at module start, and finish searching when start == end.
594 : Note: if start == end at the beginning of the function, we go all the way around
595 : the circular list.
596 : */
597 : SWIGRUNTIME swig_type_info *
598 0 : SWIG_TypeQueryModule(swig_module_info *start,
599 : swig_module_info *end,
600 : const char *name) {
601 : /* STEP 1: Search the name field using binary search */
602 0 : swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
603 0 : if (ret) {
604 : return ret;
605 : } else {
606 : /* STEP 2: If the type hasn't been found, do a complete search
607 : of the str field (the human readable name) */
608 : swig_module_info *iter = start;
609 : do {
610 0 : size_t i = 0;
611 0 : for (; i < iter->size; ++i) {
612 0 : if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
613 : return iter->types[i];
614 : }
615 0 : iter = iter->next;
616 0 : } while (iter != end);
617 : }
618 :
619 : /* neither found a match */
620 : return 0;
621 : }
622 :
623 : /*
624 : Pack binary data into a string
625 : */
626 : SWIGRUNTIME char *
627 : SWIG_PackData(char *c, void *ptr, size_t sz) {
628 : static const char hex[17] = "0123456789abcdef";
629 0 : const unsigned char *u = (unsigned char *) ptr;
630 0 : const unsigned char *eu = u + sz;
631 0 : for (; u != eu; ++u) {
632 0 : unsigned char uu = *u;
633 0 : *(c++) = hex[(uu & 0xf0) >> 4];
634 0 : *(c++) = hex[uu & 0xf];
635 : }
636 : return c;
637 : }
638 :
639 : /*
640 : Unpack binary data from a string
641 : */
642 : SWIGRUNTIME const char *
643 0 : SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
644 0 : unsigned char *u = (unsigned char *) ptr;
645 0 : const unsigned char *eu = u + sz;
646 0 : for (; u != eu; ++u) {
647 0 : char d = *(c++);
648 : unsigned char uu;
649 0 : if ((d >= '0') && (d <= '9'))
650 0 : uu = (unsigned char)((d - '0') << 4);
651 0 : else if ((d >= 'a') && (d <= 'f'))
652 0 : uu = (unsigned char)((d - ('a'-10)) << 4);
653 : else
654 : return (char *) 0;
655 0 : d = *(c++);
656 0 : if ((d >= '0') && (d <= '9'))
657 0 : uu |= (unsigned char)(d - '0');
658 0 : else if ((d >= 'a') && (d <= 'f'))
659 0 : uu |= (unsigned char)(d - ('a'-10));
660 : else
661 : return (char *) 0;
662 0 : *u = uu;
663 : }
664 : return c;
665 : }
666 :
667 : /*
668 : Pack 'void *' into a string buffer.
669 : */
670 : SWIGRUNTIME char *
671 0 : SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
672 0 : char *r = buff;
673 0 : if ((2*sizeof(void *) + 2) > bsz) return 0;
674 0 : *(r++) = '_';
675 0 : r = SWIG_PackData(r,&ptr,sizeof(void *));
676 0 : if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
677 0 : strcpy(r,name);
678 0 : return buff;
679 : }
680 :
681 : SWIGRUNTIME const char *
682 0 : SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
683 0 : if (*c != '_') {
684 0 : if (strcmp(c,"NULL") == 0) {
685 0 : *ptr = (void *) 0;
686 0 : return name;
687 : } else {
688 : return 0;
689 : }
690 : }
691 0 : return SWIG_UnpackData(++c,ptr,sizeof(void *));
692 : }
693 :
694 : SWIGRUNTIME char *
695 0 : SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
696 0 : char *r = buff;
697 0 : size_t lname = (name ? strlen(name) : 0);
698 0 : if ((2*sz + 2 + lname) > bsz) return 0;
699 0 : *(r++) = '_';
700 0 : r = SWIG_PackData(r,ptr,sz);
701 0 : if (lname) {
702 0 : strncpy(r,name,lname+1);
703 : } else {
704 0 : *r = 0;
705 : }
706 : return buff;
707 : }
708 :
709 : SWIGRUNTIME const char *
710 : SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
711 : if (*c != '_') {
712 : if (strcmp(c,"NULL") == 0) {
713 : memset(ptr,0,sz);
714 : return name;
715 : } else {
716 : return 0;
717 : }
718 : }
719 : return SWIG_UnpackData(++c,ptr,sz);
720 : }
721 :
722 : #ifdef __cplusplus
723 : }
724 : #endif
725 :
726 : /* Errors in SWIG */
727 : #define SWIG_UnknownError -1
728 : #define SWIG_IOError -2
729 : #define SWIG_RuntimeError -3
730 : #define SWIG_IndexError -4
731 : #define SWIG_TypeError -5
732 : #define SWIG_DivisionByZero -6
733 : #define SWIG_OverflowError -7
734 : #define SWIG_SyntaxError -8
735 : #define SWIG_ValueError -9
736 : #define SWIG_SystemError -10
737 : #define SWIG_AttributeError -11
738 : #define SWIG_MemoryError -12
739 : #define SWIG_NullReferenceError -13
740 :
741 :
742 :
743 : /* Compatibility macros for Python 3 */
744 : #if PY_VERSION_HEX >= 0x03000000
745 :
746 : #define PyClass_Check(obj) PyObject_IsInstance(obj, (PyObject *)&PyType_Type)
747 : #define PyInt_Check(x) PyLong_Check(x)
748 : #define PyInt_AsLong(x) PyLong_AsLong(x)
749 : #define PyInt_FromLong(x) PyLong_FromLong(x)
750 : #define PyInt_FromSize_t(x) PyLong_FromSize_t(x)
751 : #define PyString_Check(name) PyBytes_Check(name)
752 : #define PyString_FromString(x) PyUnicode_FromString(x)
753 : #define PyString_Format(fmt, args) PyUnicode_Format(fmt, args)
754 : #define PyString_AsString(str) PyBytes_AsString(str)
755 : #define PyString_Size(str) PyBytes_Size(str)
756 : #define PyString_InternFromString(key) PyUnicode_InternFromString(key)
757 : #define Py_TPFLAGS_HAVE_CLASS Py_TPFLAGS_BASETYPE
758 : #define PyString_AS_STRING(x) PyUnicode_AS_STRING(x)
759 : #define _PyLong_FromSsize_t(x) PyLong_FromSsize_t(x)
760 :
761 : #endif
762 :
763 : #ifndef Py_TYPE
764 : # define Py_TYPE(op) ((op)->ob_type)
765 : #endif
766 :
767 : /* SWIG APIs for compatibility of both Python 2 & 3 */
768 :
769 : #if PY_VERSION_HEX >= 0x03000000
770 : # define SWIG_Python_str_FromFormat PyUnicode_FromFormat
771 : #else
772 : # define SWIG_Python_str_FromFormat PyString_FromFormat
773 : #endif
774 :
775 :
776 : /* Warning: This function will allocate a new string in Python 3,
777 : * so please call SWIG_Python_str_DelForPy3(x) to free the space.
778 : */
779 : SWIGINTERN char*
780 : SWIG_Python_str_AsChar(PyObject *str)
781 : {
782 : #if PY_VERSION_HEX >= 0x03000000
783 : char *cstr;
784 : char *newstr;
785 : Py_ssize_t len;
786 : str = PyUnicode_AsUTF8String(str);
787 : PyBytes_AsStringAndSize(str, &cstr, &len);
788 : newstr = (char *) malloc(len+1);
789 : memcpy(newstr, cstr, len+1);
790 : Py_XDECREF(str);
791 : return newstr;
792 : #else
793 0 : return PyString_AsString(str);
794 : #endif
795 : }
796 :
797 : #if PY_VERSION_HEX >= 0x03000000
798 : # define SWIG_Python_str_DelForPy3(x) free( (void*) (x) )
799 : #else
800 : # define SWIG_Python_str_DelForPy3(x)
801 : #endif
802 :
803 :
804 : SWIGINTERN PyObject*
805 : SWIG_Python_str_FromChar(const char *c)
806 : {
807 : #if PY_VERSION_HEX >= 0x03000000
808 : return PyUnicode_FromString(c);
809 : #else
810 27 : return PyString_FromString(c);
811 : #endif
812 : }
813 :
814 : /* Add PyOS_snprintf for old Pythons */
815 : #if PY_VERSION_HEX < 0x02020000
816 : # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
817 : # define PyOS_snprintf _snprintf
818 : # else
819 : # define PyOS_snprintf snprintf
820 : # endif
821 : #endif
822 :
823 : /* A crude PyString_FromFormat implementation for old Pythons */
824 : #if PY_VERSION_HEX < 0x02020000
825 :
826 : #ifndef SWIG_PYBUFFER_SIZE
827 : # define SWIG_PYBUFFER_SIZE 1024
828 : #endif
829 :
830 : static PyObject *
831 : PyString_FromFormat(const char *fmt, ...) {
832 : va_list ap;
833 : char buf[SWIG_PYBUFFER_SIZE * 2];
834 : int res;
835 : va_start(ap, fmt);
836 : res = vsnprintf(buf, sizeof(buf), fmt, ap);
837 : va_end(ap);
838 : return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
839 : }
840 : #endif
841 :
842 : #ifndef PyObject_DEL
843 : # define PyObject_DEL PyObject_Del
844 : #endif
845 :
846 : /* A crude PyExc_StopIteration exception for old Pythons */
847 : #if PY_VERSION_HEX < 0x02020000
848 : # ifndef PyExc_StopIteration
849 : # define PyExc_StopIteration PyExc_RuntimeError
850 : # endif
851 : # ifndef PyObject_GenericGetAttr
852 : # define PyObject_GenericGetAttr 0
853 : # endif
854 : #endif
855 :
856 : /* Py_NotImplemented is defined in 2.1 and up. */
857 : #if PY_VERSION_HEX < 0x02010000
858 : # ifndef Py_NotImplemented
859 : # define Py_NotImplemented PyExc_RuntimeError
860 : # endif
861 : #endif
862 :
863 : /* A crude PyString_AsStringAndSize implementation for old Pythons */
864 : #if PY_VERSION_HEX < 0x02010000
865 : # ifndef PyString_AsStringAndSize
866 : # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
867 : # endif
868 : #endif
869 :
870 : /* PySequence_Size for old Pythons */
871 : #if PY_VERSION_HEX < 0x02000000
872 : # ifndef PySequence_Size
873 : # define PySequence_Size PySequence_Length
874 : # endif
875 : #endif
876 :
877 : /* PyBool_FromLong for old Pythons */
878 : #if PY_VERSION_HEX < 0x02030000
879 : static
880 : PyObject *PyBool_FromLong(long ok)
881 : {
882 : PyObject *result = ok ? Py_True : Py_False;
883 : Py_INCREF(result);
884 : return result;
885 : }
886 : #endif
887 :
888 : /* Py_ssize_t for old Pythons */
889 : /* This code is as recommended by: */
890 : /* http://www.python.org/dev/peps/pep-0353/#conversion-guidelines */
891 : #if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN)
892 : typedef int Py_ssize_t;
893 : # define PY_SSIZE_T_MAX INT_MAX
894 : # define PY_SSIZE_T_MIN INT_MIN
895 : typedef inquiry lenfunc;
896 : typedef intargfunc ssizeargfunc;
897 : typedef intintargfunc ssizessizeargfunc;
898 : typedef intobjargproc ssizeobjargproc;
899 : typedef intintobjargproc ssizessizeobjargproc;
900 : typedef getreadbufferproc readbufferproc;
901 : typedef getwritebufferproc writebufferproc;
902 : typedef getsegcountproc segcountproc;
903 : typedef getcharbufferproc charbufferproc;
904 : static long PyNumber_AsSsize_t (PyObject *x, void *SWIGUNUSEDPARM(exc))
905 : {
906 : long result = 0;
907 : PyObject *i = PyNumber_Int(x);
908 : if (i) {
909 : result = PyInt_AsLong(i);
910 : Py_DECREF(i);
911 : }
912 : return result;
913 : }
914 : #endif
915 :
916 : #if PY_VERSION_HEX < 0x02050000
917 : #define PyInt_FromSize_t(x) PyInt_FromLong((long)x)
918 : #endif
919 :
920 : #if PY_VERSION_HEX < 0x02040000
921 : #define Py_VISIT(op) \
922 : do { \
923 : if (op) { \
924 : int vret = visit((op), arg); \
925 : if (vret) \
926 : return vret; \
927 : } \
928 : } while (0)
929 : #endif
930 :
931 : #if PY_VERSION_HEX < 0x02030000
932 : typedef struct {
933 : PyTypeObject type;
934 : PyNumberMethods as_number;
935 : PyMappingMethods as_mapping;
936 : PySequenceMethods as_sequence;
937 : PyBufferProcs as_buffer;
938 : PyObject *name, *slots;
939 : } PyHeapTypeObject;
940 : #endif
941 :
942 : #if PY_VERSION_HEX < 0x02030000
943 : typedef destructor freefunc;
944 : #endif
945 :
946 : #if ((PY_MAJOR_VERSION == 2 && PY_MINOR_VERSION > 6) || \
947 : (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION > 0) || \
948 : (PY_MAJOR_VERSION > 3))
949 : # define SWIGPY_USE_CAPSULE
950 : # define SWIGPY_CAPSULE_NAME ((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION ".type_pointer_capsule" SWIG_TYPE_TABLE_NAME)
951 : #endif
952 :
953 : #if PY_VERSION_HEX < 0x03020000
954 : #define PyDescr_TYPE(x) (((PyDescrObject *)(x))->d_type)
955 : #define PyDescr_NAME(x) (((PyDescrObject *)(x))->d_name)
956 : #endif
957 :
958 : /* -----------------------------------------------------------------------------
959 : * error manipulation
960 : * ----------------------------------------------------------------------------- */
961 :
962 : SWIGRUNTIME PyObject*
963 0 : SWIG_Python_ErrorType(int code) {
964 0 : PyObject* type = 0;
965 0 : switch(code) {
966 : case SWIG_MemoryError:
967 0 : type = PyExc_MemoryError;
968 0 : break;
969 : case SWIG_IOError:
970 0 : type = PyExc_IOError;
971 0 : break;
972 : case SWIG_RuntimeError:
973 0 : type = PyExc_RuntimeError;
974 0 : break;
975 : case SWIG_IndexError:
976 0 : type = PyExc_IndexError;
977 0 : break;
978 : case SWIG_TypeError:
979 0 : type = PyExc_TypeError;
980 0 : break;
981 : case SWIG_DivisionByZero:
982 0 : type = PyExc_ZeroDivisionError;
983 0 : break;
984 : case SWIG_OverflowError:
985 0 : type = PyExc_OverflowError;
986 0 : break;
987 : case SWIG_SyntaxError:
988 0 : type = PyExc_SyntaxError;
989 0 : break;
990 : case SWIG_ValueError:
991 0 : type = PyExc_ValueError;
992 0 : break;
993 : case SWIG_SystemError:
994 0 : type = PyExc_SystemError;
995 0 : break;
996 : case SWIG_AttributeError:
997 0 : type = PyExc_AttributeError;
998 0 : break;
999 : default:
1000 0 : type = PyExc_RuntimeError;
1001 : }
1002 0 : return type;
1003 : }
1004 :
1005 :
1006 : SWIGRUNTIME void
1007 : SWIG_Python_AddErrorMsg(const char* mesg)
1008 : {
1009 : PyObject *type = 0;
1010 : PyObject *value = 0;
1011 : PyObject *traceback = 0;
1012 :
1013 : if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
1014 : if (value) {
1015 : char *tmp;
1016 : PyObject *old_str = PyObject_Str(value);
1017 : PyErr_Clear();
1018 : Py_XINCREF(type);
1019 :
1020 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
1021 : SWIG_Python_str_DelForPy3(tmp);
1022 : Py_DECREF(old_str);
1023 : Py_DECREF(value);
1024 : } else {
1025 : PyErr_SetString(PyExc_RuntimeError, mesg);
1026 : }
1027 : }
1028 :
1029 : #if defined(SWIG_PYTHON_NO_THREADS)
1030 : # if defined(SWIG_PYTHON_THREADS)
1031 : # undef SWIG_PYTHON_THREADS
1032 : # endif
1033 : #endif
1034 : #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
1035 : # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
1036 : # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
1037 : # define SWIG_PYTHON_USE_GIL
1038 : # endif
1039 : # endif
1040 : # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
1041 : # ifndef SWIG_PYTHON_INITIALIZE_THREADS
1042 : # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
1043 : # endif
1044 : # ifdef __cplusplus /* C++ code */
1045 : class SWIG_Python_Thread_Block {
1046 : bool status;
1047 : PyGILState_STATE state;
1048 : public:
1049 : void end() { if (status) { PyGILState_Release(state); status = false;} }
1050 : SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
1051 : ~SWIG_Python_Thread_Block() { end(); }
1052 : };
1053 : class SWIG_Python_Thread_Allow {
1054 : bool status;
1055 : PyThreadState *save;
1056 : public:
1057 : void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
1058 : SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
1059 : ~SWIG_Python_Thread_Allow() { end(); }
1060 : };
1061 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
1062 : # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
1063 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
1064 : # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
1065 : # else /* C code */
1066 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
1067 : # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
1068 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
1069 : # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
1070 : # endif
1071 : # else /* Old thread way, not implemented, user must provide it */
1072 : # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
1073 : # define SWIG_PYTHON_INITIALIZE_THREADS
1074 : # endif
1075 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
1076 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1077 : # endif
1078 : # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
1079 : # define SWIG_PYTHON_THREAD_END_BLOCK
1080 : # endif
1081 : # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
1082 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1083 : # endif
1084 : # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
1085 : # define SWIG_PYTHON_THREAD_END_ALLOW
1086 : # endif
1087 : # endif
1088 : #else /* No thread support */
1089 : # define SWIG_PYTHON_INITIALIZE_THREADS
1090 : # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
1091 : # define SWIG_PYTHON_THREAD_END_BLOCK
1092 : # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
1093 : # define SWIG_PYTHON_THREAD_END_ALLOW
1094 : #endif
1095 :
1096 : /* -----------------------------------------------------------------------------
1097 : * Python API portion that goes into the runtime
1098 : * ----------------------------------------------------------------------------- */
1099 :
1100 : #ifdef __cplusplus
1101 : extern "C" {
1102 : #endif
1103 :
1104 : /* -----------------------------------------------------------------------------
1105 : * Constant declarations
1106 : * ----------------------------------------------------------------------------- */
1107 :
1108 : /* Constant Types */
1109 : #define SWIG_PY_POINTER 4
1110 : #define SWIG_PY_BINARY 5
1111 :
1112 : /* Constant information structure */
1113 : typedef struct swig_const_info {
1114 : int type;
1115 : char *name;
1116 : long lvalue;
1117 : double dvalue;
1118 : void *pvalue;
1119 : swig_type_info **ptype;
1120 : } swig_const_info;
1121 :
1122 :
1123 : /* -----------------------------------------------------------------------------
1124 : * Wrapper of PyInstanceMethod_New() used in Python 3
1125 : * It is exported to the generated module, used for -fastproxy
1126 : * ----------------------------------------------------------------------------- */
1127 : #if PY_VERSION_HEX >= 0x03000000
1128 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *func)
1129 : {
1130 : return PyInstanceMethod_New(func);
1131 : }
1132 : #else
1133 0 : SWIGRUNTIME PyObject* SWIG_PyInstanceMethod_New(PyObject *SWIGUNUSEDPARM(self), PyObject *SWIGUNUSEDPARM(func))
1134 : {
1135 0 : return NULL;
1136 : }
1137 : #endif
1138 :
1139 : #ifdef __cplusplus
1140 : }
1141 : #endif
1142 :
1143 :
1144 : /* -----------------------------------------------------------------------------
1145 : * pyrun.swg
1146 : *
1147 : * This file contains the runtime support for Python modules
1148 : * and includes code for managing global variables and pointer
1149 : * type checking.
1150 : *
1151 : * ----------------------------------------------------------------------------- */
1152 :
1153 : /* Common SWIG API */
1154 :
1155 : /* for raw pointers */
1156 : #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
1157 : #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
1158 : #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
1159 :
1160 : #ifdef SWIGPYTHON_BUILTIN
1161 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(self, ptr, type, flags)
1162 : #else
1163 : #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1164 : #endif
1165 :
1166 : #define SWIG_InternalNewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(NULL, ptr, type, flags)
1167 :
1168 : #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
1169 : #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
1170 : #define swig_owntype int
1171 :
1172 : /* for raw packed data */
1173 : #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1174 : #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1175 :
1176 : /* for class or struct pointers */
1177 : #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1178 : #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1179 :
1180 : /* for C or C++ function pointers */
1181 : #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1182 : #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(NULL, ptr, type, 0)
1183 :
1184 : /* for C++ member pointers, ie, member methods */
1185 : #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1186 : #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1187 :
1188 :
1189 : /* Runtime API */
1190 :
1191 : #define SWIG_GetModule(clientdata) SWIG_Python_GetModule(clientdata)
1192 : #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1193 : #define SWIG_NewClientData(obj) SwigPyClientData_New(obj)
1194 :
1195 : #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1196 : #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1197 : #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1198 : #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1199 : #define SWIG_fail goto fail
1200 :
1201 :
1202 : /* Runtime API implementation */
1203 :
1204 : /* Error manipulation */
1205 :
1206 : SWIGINTERN void
1207 : SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1208 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1209 : PyErr_SetObject(errtype, obj);
1210 : Py_DECREF(obj);
1211 : SWIG_PYTHON_THREAD_END_BLOCK;
1212 : }
1213 :
1214 : SWIGINTERN void
1215 0 : SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1216 0 : SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1217 0 : PyErr_SetString(errtype, msg);
1218 0 : SWIG_PYTHON_THREAD_END_BLOCK;
1219 0 : }
1220 :
1221 : #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1222 :
1223 : /* Set a constant value */
1224 :
1225 : #if defined(SWIGPYTHON_BUILTIN)
1226 :
1227 : SWIGINTERN void
1228 : SwigPyBuiltin_AddPublicSymbol(PyObject *seq, const char *key) {
1229 : PyObject *s = PyString_InternFromString(key);
1230 : PyList_Append(seq, s);
1231 : Py_DECREF(s);
1232 : }
1233 :
1234 : SWIGINTERN void
1235 : SWIG_Python_SetConstant(PyObject *d, PyObject *public_interface, const char *name, PyObject *obj) {
1236 : #if PY_VERSION_HEX < 0x02030000
1237 : PyDict_SetItemString(d, (char *)name, obj);
1238 : #else
1239 : PyDict_SetItemString(d, name, obj);
1240 : #endif
1241 : Py_DECREF(obj);
1242 : if (public_interface)
1243 : SwigPyBuiltin_AddPublicSymbol(public_interface, name);
1244 : }
1245 :
1246 : #else
1247 :
1248 : SWIGINTERN void
1249 24975 : SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1250 : #if PY_VERSION_HEX < 0x02030000
1251 : PyDict_SetItemString(d, (char *)name, obj);
1252 : #else
1253 24975 : PyDict_SetItemString(d, name, obj);
1254 : #endif
1255 24975 : Py_DECREF(obj);
1256 24975 : }
1257 :
1258 : #endif
1259 :
1260 : /* Append a value to the result obj */
1261 :
1262 : SWIGINTERN PyObject*
1263 : SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1264 : #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1265 : if (!result) {
1266 : result = obj;
1267 : } else if (result == Py_None) {
1268 : Py_DECREF(result);
1269 : result = obj;
1270 : } else {
1271 : if (!PyList_Check(result)) {
1272 : PyObject *o2 = result;
1273 : result = PyList_New(1);
1274 : PyList_SetItem(result, 0, o2);
1275 : }
1276 : PyList_Append(result,obj);
1277 : Py_DECREF(obj);
1278 : }
1279 : return result;
1280 : #else
1281 : PyObject* o2;
1282 : PyObject* o3;
1283 : if (!result) {
1284 : result = obj;
1285 : } else if (result == Py_None) {
1286 : Py_DECREF(result);
1287 : result = obj;
1288 : } else {
1289 : if (!PyTuple_Check(result)) {
1290 : o2 = result;
1291 : result = PyTuple_New(1);
1292 : PyTuple_SET_ITEM(result, 0, o2);
1293 : }
1294 : o3 = PyTuple_New(1);
1295 : PyTuple_SET_ITEM(o3, 0, obj);
1296 : o2 = result;
1297 : result = PySequence_Concat(o2, o3);
1298 : Py_DECREF(o2);
1299 : Py_DECREF(o3);
1300 : }
1301 : return result;
1302 : #endif
1303 : }
1304 :
1305 : /* Unpack the argument tuple */
1306 :
1307 : SWIGINTERN Py_ssize_t
1308 : SWIG_Python_UnpackTuple(PyObject *args, const char *name, Py_ssize_t min, Py_ssize_t max, PyObject **objs)
1309 : {
1310 : if (!args) {
1311 : if (!min && !max) {
1312 : return 1;
1313 : } else {
1314 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1315 : name, (min == max ? "" : "at least "), (int)min);
1316 : return 0;
1317 : }
1318 : }
1319 : if (!PyTuple_Check(args)) {
1320 : if (min <= 1 && max >= 1) {
1321 : Py_ssize_t i;
1322 : objs[0] = args;
1323 : for (i = 1; i < max; ++i) {
1324 : objs[i] = 0;
1325 : }
1326 : return 2;
1327 : }
1328 : PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1329 : return 0;
1330 : } else {
1331 : Py_ssize_t l = PyTuple_GET_SIZE(args);
1332 : if (l < min) {
1333 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1334 : name, (min == max ? "" : "at least "), (int)min, (int)l);
1335 : return 0;
1336 : } else if (l > max) {
1337 : PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1338 : name, (min == max ? "" : "at most "), (int)max, (int)l);
1339 : return 0;
1340 : } else {
1341 : Py_ssize_t i;
1342 : for (i = 0; i < l; ++i) {
1343 : objs[i] = PyTuple_GET_ITEM(args, i);
1344 : }
1345 : for (; l < max; ++l) {
1346 : objs[l] = 0;
1347 : }
1348 : return i + 1;
1349 : }
1350 : }
1351 : }
1352 :
1353 : /* A functor is a function object with one single object argument */
1354 : #if PY_VERSION_HEX >= 0x02020000
1355 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1356 : #else
1357 : #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1358 : #endif
1359 :
1360 : /*
1361 : Helper for static pointer initialization for both C and C++ code, for example
1362 : static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1363 : */
1364 : #ifdef __cplusplus
1365 : #define SWIG_STATIC_POINTER(var) var
1366 : #else
1367 : #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1368 : #endif
1369 :
1370 : /* -----------------------------------------------------------------------------
1371 : * Pointer declarations
1372 : * ----------------------------------------------------------------------------- */
1373 :
1374 : /* Flags for new pointer objects */
1375 : #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1376 : #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1377 :
1378 : #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1379 :
1380 : #define SWIG_BUILTIN_TP_INIT (SWIG_POINTER_OWN << 2)
1381 : #define SWIG_BUILTIN_INIT (SWIG_BUILTIN_TP_INIT | SWIG_POINTER_OWN)
1382 :
1383 : #ifdef __cplusplus
1384 : extern "C" {
1385 : #endif
1386 :
1387 : /* How to access Py_None */
1388 : #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1389 : # ifndef SWIG_PYTHON_NO_BUILD_NONE
1390 : # ifndef SWIG_PYTHON_BUILD_NONE
1391 : # define SWIG_PYTHON_BUILD_NONE
1392 : # endif
1393 : # endif
1394 : #endif
1395 :
1396 : #ifdef SWIG_PYTHON_BUILD_NONE
1397 : # ifdef Py_None
1398 : # undef Py_None
1399 : # define Py_None SWIG_Py_None()
1400 : # endif
1401 : SWIGRUNTIMEINLINE PyObject *
1402 : _SWIG_Py_None(void)
1403 : {
1404 : PyObject *none = Py_BuildValue((char*)"");
1405 : Py_DECREF(none);
1406 : return none;
1407 : }
1408 : SWIGRUNTIME PyObject *
1409 : SWIG_Py_None(void)
1410 : {
1411 : static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1412 : return none;
1413 : }
1414 : #endif
1415 :
1416 : /* The python void return value */
1417 :
1418 : SWIGRUNTIMEINLINE PyObject *
1419 : SWIG_Py_Void(void)
1420 : {
1421 1942 : PyObject *none = Py_None;
1422 1942 : Py_INCREF(none);
1423 : return none;
1424 : }
1425 :
1426 : /* SwigPyClientData */
1427 :
1428 : typedef struct {
1429 : PyObject *klass;
1430 : PyObject *newraw;
1431 : PyObject *newargs;
1432 : PyObject *destroy;
1433 : int delargs;
1434 : int implicitconv;
1435 : PyTypeObject *pytype;
1436 : } SwigPyClientData;
1437 :
1438 : SWIGRUNTIMEINLINE int
1439 : SWIG_Python_CheckImplicit(swig_type_info *ty)
1440 : {
1441 : SwigPyClientData *data = (SwigPyClientData *)ty->clientdata;
1442 : return data ? data->implicitconv : 0;
1443 : }
1444 :
1445 : SWIGRUNTIMEINLINE PyObject *
1446 : SWIG_Python_ExceptionType(swig_type_info *desc) {
1447 : SwigPyClientData *data = desc ? (SwigPyClientData *) desc->clientdata : 0;
1448 : PyObject *klass = data ? data->klass : 0;
1449 : return (klass ? klass : PyExc_RuntimeError);
1450 : }
1451 :
1452 :
1453 : SWIGRUNTIME SwigPyClientData *
1454 810 : SwigPyClientData_New(PyObject* obj)
1455 : {
1456 810 : if (!obj) {
1457 : return 0;
1458 : } else {
1459 810 : SwigPyClientData *data = (SwigPyClientData *)malloc(sizeof(SwigPyClientData));
1460 : /* the klass element */
1461 810 : data->klass = obj;
1462 810 : Py_INCREF(data->klass);
1463 : /* the newraw method and newargs arguments used to create a new raw instance */
1464 810 : if (PyClass_Check(obj)) {
1465 0 : data->newraw = 0;
1466 0 : data->newargs = obj;
1467 0 : Py_INCREF(obj);
1468 : } else {
1469 : #if (PY_VERSION_HEX < 0x02020000)
1470 : data->newraw = 0;
1471 : #else
1472 810 : data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1473 : #endif
1474 810 : if (data->newraw) {
1475 810 : Py_INCREF(data->newraw);
1476 810 : data->newargs = PyTuple_New(1);
1477 810 : PyTuple_SetItem(data->newargs, 0, obj);
1478 : } else {
1479 0 : data->newargs = obj;
1480 : }
1481 810 : Py_INCREF(data->newargs);
1482 : }
1483 : /* the destroy method, aka as the C++ delete method */
1484 810 : data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1485 810 : if (PyErr_Occurred()) {
1486 0 : PyErr_Clear();
1487 0 : data->destroy = 0;
1488 : }
1489 810 : if (data->destroy) {
1490 : int flags;
1491 810 : Py_INCREF(data->destroy);
1492 810 : flags = PyCFunction_GET_FLAGS(data->destroy);
1493 : #ifdef METH_O
1494 810 : data->delargs = !(flags & (METH_O));
1495 : #else
1496 : data->delargs = 0;
1497 : #endif
1498 : } else {
1499 0 : data->delargs = 0;
1500 : }
1501 810 : data->implicitconv = 0;
1502 810 : data->pytype = 0;
1503 810 : return data;
1504 : }
1505 : }
1506 :
1507 : SWIGRUNTIME void
1508 810 : SwigPyClientData_Del(SwigPyClientData *data) {
1509 810 : Py_XDECREF(data->newraw);
1510 810 : Py_XDECREF(data->newargs);
1511 810 : Py_XDECREF(data->destroy);
1512 810 : }
1513 :
1514 : /* =============== SwigPyObject =====================*/
1515 :
1516 : typedef struct {
1517 : PyObject_HEAD
1518 : void *ptr;
1519 : swig_type_info *ty;
1520 : int own;
1521 : PyObject *next;
1522 : #ifdef SWIGPYTHON_BUILTIN
1523 : PyObject *dict;
1524 : #endif
1525 : } SwigPyObject;
1526 :
1527 :
1528 : #ifdef SWIGPYTHON_BUILTIN
1529 :
1530 : SWIGRUNTIME PyObject *
1531 : SwigPyObject_get___dict__(PyObject *v, PyObject *SWIGUNUSEDPARM(args))
1532 : {
1533 : SwigPyObject *sobj = (SwigPyObject *)v;
1534 :
1535 : if (!sobj->dict)
1536 : sobj->dict = PyDict_New();
1537 :
1538 : Py_INCREF(sobj->dict);
1539 : return sobj->dict;
1540 : }
1541 :
1542 : #endif
1543 :
1544 : SWIGRUNTIME PyObject *
1545 0 : SwigPyObject_long(SwigPyObject *v)
1546 : {
1547 0 : return PyLong_FromVoidPtr(v->ptr);
1548 : }
1549 :
1550 : SWIGRUNTIME PyObject *
1551 0 : SwigPyObject_format(const char* fmt, SwigPyObject *v)
1552 : {
1553 0 : PyObject *res = NULL;
1554 0 : PyObject *args = PyTuple_New(1);
1555 0 : if (args) {
1556 0 : if (PyTuple_SetItem(args, 0, SwigPyObject_long(v)) == 0) {
1557 0 : PyObject *ofmt = SWIG_Python_str_FromChar(fmt);
1558 0 : if (ofmt) {
1559 : #if PY_VERSION_HEX >= 0x03000000
1560 : res = PyUnicode_Format(ofmt,args);
1561 : #else
1562 0 : res = PyString_Format(ofmt,args);
1563 : #endif
1564 0 : Py_DECREF(ofmt);
1565 : }
1566 0 : Py_DECREF(args);
1567 : }
1568 : }
1569 0 : return res;
1570 : }
1571 :
1572 : SWIGRUNTIME PyObject *
1573 0 : SwigPyObject_oct(SwigPyObject *v)
1574 : {
1575 0 : return SwigPyObject_format("%o",v);
1576 : }
1577 :
1578 : SWIGRUNTIME PyObject *
1579 0 : SwigPyObject_hex(SwigPyObject *v)
1580 : {
1581 0 : return SwigPyObject_format("%x",v);
1582 : }
1583 :
1584 : SWIGRUNTIME PyObject *
1585 : #ifdef METH_NOARGS
1586 0 : SwigPyObject_repr(SwigPyObject *v)
1587 : #else
1588 : SwigPyObject_repr(SwigPyObject *v, PyObject *args)
1589 : #endif
1590 : {
1591 0 : const char *name = SWIG_TypePrettyName(v->ty);
1592 0 : PyObject *repr = SWIG_Python_str_FromFormat("<Swig Object of type '%s' at %p>", (name ? name : "unknown"), (void *)v);
1593 0 : if (v->next) {
1594 : # ifdef METH_NOARGS
1595 0 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next);
1596 : # else
1597 : PyObject *nrep = SwigPyObject_repr((SwigPyObject *)v->next, args);
1598 : # endif
1599 : # if PY_VERSION_HEX >= 0x03000000
1600 : PyObject *joined = PyUnicode_Concat(repr, nrep);
1601 : Py_DecRef(repr);
1602 : Py_DecRef(nrep);
1603 : repr = joined;
1604 : # else
1605 0 : PyString_ConcatAndDel(&repr,nrep);
1606 : # endif
1607 : }
1608 0 : return repr;
1609 : }
1610 :
1611 : SWIGRUNTIME int
1612 0 : SwigPyObject_compare(SwigPyObject *v, SwigPyObject *w)
1613 : {
1614 101 : void *i = v->ptr;
1615 101 : void *j = w->ptr;
1616 101 : return (i < j) ? -1 : ((i > j) ? 1 : 0);
1617 : }
1618 :
1619 : /* Added for Python 3.x, would it also be useful for Python 2.x? */
1620 : SWIGRUNTIME PyObject*
1621 101 : SwigPyObject_richcompare(SwigPyObject *v, SwigPyObject *w, int op)
1622 : {
1623 : PyObject* res;
1624 101 : if( op != Py_EQ && op != Py_NE ) {
1625 0 : Py_INCREF(Py_NotImplemented);
1626 0 : return Py_NotImplemented;
1627 : }
1628 101 : res = PyBool_FromLong( (SwigPyObject_compare(v, w)==0) == (op == Py_EQ) ? 1 : 0);
1629 101 : return res;
1630 : }
1631 :
1632 :
1633 : SWIGRUNTIME PyTypeObject* SwigPyObject_TypeOnce(void);
1634 :
1635 : #ifdef SWIGPYTHON_BUILTIN
1636 : static swig_type_info *SwigPyObject_stype = 0;
1637 : SWIGRUNTIME PyTypeObject*
1638 : SwigPyObject_type(void) {
1639 : SwigPyClientData *cd;
1640 : assert(SwigPyObject_stype);
1641 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
1642 : assert(cd);
1643 : assert(cd->pytype);
1644 : return cd->pytype;
1645 : }
1646 : #else
1647 : SWIGRUNTIME PyTypeObject*
1648 : SwigPyObject_type(void) {
1649 16324 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyObject_TypeOnce();
1650 16324 : return type;
1651 : }
1652 : #endif
1653 :
1654 : SWIGRUNTIMEINLINE int
1655 12468 : SwigPyObject_Check(PyObject *op) {
1656 : #ifdef SWIGPYTHON_BUILTIN
1657 : PyTypeObject *target_tp = SwigPyObject_type();
1658 : if (PyType_IsSubtype(op->ob_type, target_tp))
1659 : return 1;
1660 : return (strcmp(op->ob_type->tp_name, "SwigPyObject") == 0);
1661 : #else
1662 12468 : return (Py_TYPE(op) == SwigPyObject_type())
1663 12468 : || (strcmp(Py_TYPE(op)->tp_name,"SwigPyObject") == 0);
1664 : #endif
1665 : }
1666 :
1667 : SWIGRUNTIME PyObject *
1668 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own);
1669 :
1670 : SWIGRUNTIME void
1671 1915 : SwigPyObject_dealloc(PyObject *v)
1672 : {
1673 1915 : SwigPyObject *sobj = (SwigPyObject *) v;
1674 1915 : PyObject *next = sobj->next;
1675 1915 : if (sobj->own == SWIG_POINTER_OWN) {
1676 0 : swig_type_info *ty = sobj->ty;
1677 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
1678 0 : PyObject *destroy = data ? data->destroy : 0;
1679 0 : if (destroy) {
1680 : /* destroy is always a VARARGS method */
1681 : PyObject *res;
1682 :
1683 : /* PyObject_CallFunction() has the potential to silently drop
1684 : the active active exception. In cases of unnamed temporary
1685 : variable or where we just finished iterating over a generator
1686 : StopIteration will be active right now, and this needs to
1687 : remain true upon return from SwigPyObject_dealloc. So save
1688 : and restore. */
1689 :
1690 0 : PyObject *val = NULL, *type = NULL, *tb = NULL;
1691 0 : PyErr_Fetch(&val, &type, &tb);
1692 :
1693 0 : if (data->delargs) {
1694 : /* we need to create a temporary object to carry the destroy operation */
1695 0 : PyObject *tmp = SwigPyObject_New(sobj->ptr, ty, 0);
1696 0 : res = SWIG_Python_CallFunctor(destroy, tmp);
1697 0 : Py_DECREF(tmp);
1698 : } else {
1699 0 : PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1700 0 : PyObject *mself = PyCFunction_GET_SELF(destroy);
1701 0 : res = ((*meth)(mself, v));
1702 : }
1703 0 : if (!res)
1704 0 : PyErr_WriteUnraisable(destroy);
1705 :
1706 0 : PyErr_Restore(val, type, tb);
1707 :
1708 0 : Py_XDECREF(res);
1709 : }
1710 : #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1711 : else {
1712 0 : const char *name = SWIG_TypePrettyName(ty);
1713 0 : printf("swig/python detected a memory leak of type '%s', no destructor found.\n", (name ? name : "unknown"));
1714 : }
1715 : #endif
1716 : }
1717 1915 : Py_XDECREF(next);
1718 1915 : PyObject_DEL(v);
1719 1915 : }
1720 :
1721 : SWIGRUNTIME PyObject*
1722 0 : SwigPyObject_append(PyObject* v, PyObject* next)
1723 : {
1724 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1725 : #ifndef METH_O
1726 : PyObject *tmp = 0;
1727 : if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1728 : next = tmp;
1729 : #endif
1730 0 : if (!SwigPyObject_Check(next)) {
1731 0 : PyErr_SetString(PyExc_TypeError, "Attempt to append a non SwigPyObject");
1732 0 : return NULL;
1733 : }
1734 0 : sobj->next = next;
1735 0 : Py_INCREF(next);
1736 0 : return SWIG_Py_Void();
1737 : }
1738 :
1739 : SWIGRUNTIME PyObject*
1740 : #ifdef METH_NOARGS
1741 0 : SwigPyObject_next(PyObject* v)
1742 : #else
1743 : SwigPyObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1744 : #endif
1745 : {
1746 0 : SwigPyObject *sobj = (SwigPyObject *) v;
1747 0 : if (sobj->next) {
1748 0 : Py_INCREF(sobj->next);
1749 0 : return sobj->next;
1750 : } else {
1751 0 : return SWIG_Py_Void();
1752 : }
1753 : }
1754 :
1755 : SWIGINTERN PyObject*
1756 : #ifdef METH_NOARGS
1757 0 : SwigPyObject_disown(PyObject *v)
1758 : #else
1759 : SwigPyObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1760 : #endif
1761 : {
1762 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1763 0 : sobj->own = 0;
1764 0 : return SWIG_Py_Void();
1765 : }
1766 :
1767 : SWIGINTERN PyObject*
1768 : #ifdef METH_NOARGS
1769 0 : SwigPyObject_acquire(PyObject *v)
1770 : #else
1771 : SwigPyObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1772 : #endif
1773 : {
1774 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1775 0 : sobj->own = SWIG_POINTER_OWN;
1776 0 : return SWIG_Py_Void();
1777 : }
1778 :
1779 : SWIGINTERN PyObject*
1780 0 : SwigPyObject_own(PyObject *v, PyObject *args)
1781 : {
1782 0 : PyObject *val = 0;
1783 : #if (PY_VERSION_HEX < 0x02020000)
1784 : if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1785 : #elif (PY_VERSION_HEX < 0x02050000)
1786 : if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1787 : #else
1788 0 : if (!PyArg_UnpackTuple(args, "own", 0, 1, &val))
1789 : #endif
1790 : {
1791 : return NULL;
1792 : }
1793 : else
1794 : {
1795 0 : SwigPyObject *sobj = (SwigPyObject *)v;
1796 0 : PyObject *obj = PyBool_FromLong(sobj->own);
1797 0 : if (val) {
1798 : #ifdef METH_NOARGS
1799 0 : if (PyObject_IsTrue(val)) {
1800 : SwigPyObject_acquire(v);
1801 : } else {
1802 : SwigPyObject_disown(v);
1803 : }
1804 : #else
1805 : if (PyObject_IsTrue(val)) {
1806 : SwigPyObject_acquire(v,args);
1807 : } else {
1808 : SwigPyObject_disown(v,args);
1809 : }
1810 : #endif
1811 : }
1812 : return obj;
1813 : }
1814 : }
1815 :
1816 : #ifdef METH_O
1817 : static PyMethodDef
1818 : swigobject_methods[] = {
1819 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1820 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_NOARGS, (char *)"acquires ownership of the pointer"},
1821 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1822 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_O, (char *)"appends another 'this' object"},
1823 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1824 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_NOARGS, (char *)"returns object representation"},
1825 : {0, 0, 0, 0}
1826 : };
1827 : #else
1828 : static PyMethodDef
1829 : swigobject_methods[] = {
1830 : {(char *)"disown", (PyCFunction)SwigPyObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1831 : {(char *)"acquire", (PyCFunction)SwigPyObject_acquire, METH_VARARGS, (char *)"acquires ownership of the pointer"},
1832 : {(char *)"own", (PyCFunction)SwigPyObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1833 : {(char *)"append", (PyCFunction)SwigPyObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1834 : {(char *)"next", (PyCFunction)SwigPyObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1835 : {(char *)"__repr__",(PyCFunction)SwigPyObject_repr, METH_VARARGS, (char *)"returns object representation"},
1836 : {0, 0, 0, 0}
1837 : };
1838 : #endif
1839 :
1840 : #if PY_VERSION_HEX < 0x02020000
1841 : SWIGINTERN PyObject *
1842 : SwigPyObject_getattr(SwigPyObject *sobj,char *name)
1843 : {
1844 : return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1845 : }
1846 : #endif
1847 :
1848 : SWIGRUNTIME PyTypeObject*
1849 27 : SwigPyObject_TypeOnce(void) {
1850 : static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1851 :
1852 : static PyNumberMethods SwigPyObject_as_number = {
1853 : (binaryfunc)0, /*nb_add*/
1854 : (binaryfunc)0, /*nb_subtract*/
1855 : (binaryfunc)0, /*nb_multiply*/
1856 : /* nb_divide removed in Python 3 */
1857 : #if PY_VERSION_HEX < 0x03000000
1858 : (binaryfunc)0, /*nb_divide*/
1859 : #endif
1860 : (binaryfunc)0, /*nb_remainder*/
1861 : (binaryfunc)0, /*nb_divmod*/
1862 : (ternaryfunc)0,/*nb_power*/
1863 : (unaryfunc)0, /*nb_negative*/
1864 : (unaryfunc)0, /*nb_positive*/
1865 : (unaryfunc)0, /*nb_absolute*/
1866 : (inquiry)0, /*nb_nonzero*/
1867 : 0, /*nb_invert*/
1868 : 0, /*nb_lshift*/
1869 : 0, /*nb_rshift*/
1870 : 0, /*nb_and*/
1871 : 0, /*nb_xor*/
1872 : 0, /*nb_or*/
1873 : #if PY_VERSION_HEX < 0x03000000
1874 : 0, /*nb_coerce*/
1875 : #endif
1876 : (unaryfunc)SwigPyObject_long, /*nb_int*/
1877 : #if PY_VERSION_HEX < 0x03000000
1878 : (unaryfunc)SwigPyObject_long, /*nb_long*/
1879 : #else
1880 : 0, /*nb_reserved*/
1881 : #endif
1882 : (unaryfunc)0, /*nb_float*/
1883 : #if PY_VERSION_HEX < 0x03000000
1884 : (unaryfunc)SwigPyObject_oct, /*nb_oct*/
1885 : (unaryfunc)SwigPyObject_hex, /*nb_hex*/
1886 : #endif
1887 : #if PY_VERSION_HEX >= 0x03050000 /* 3.5 */
1888 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_matrix_multiply */
1889 : #elif PY_VERSION_HEX >= 0x03000000 /* 3.0 */
1890 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index, nb_inplace_divide removed */
1891 : #elif PY_VERSION_HEX >= 0x02050000 /* 2.5.0 */
1892 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_index */
1893 : #elif PY_VERSION_HEX >= 0x02020000 /* 2.2.0 */
1894 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1895 : #elif PY_VERSION_HEX >= 0x02000000 /* 2.0.0 */
1896 : 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1897 : #endif
1898 : };
1899 :
1900 : static PyTypeObject swigpyobject_type;
1901 : static int type_init = 0;
1902 27 : if (!type_init) {
1903 : const PyTypeObject tmp = {
1904 : /* PyObject header changed in Python 3 */
1905 : #if PY_VERSION_HEX >= 0x03000000
1906 : PyVarObject_HEAD_INIT(NULL, 0)
1907 : #else
1908 : PyObject_HEAD_INIT(NULL)
1909 : 0, /* ob_size */
1910 : #endif
1911 : (char *)"SwigPyObject", /* tp_name */
1912 : sizeof(SwigPyObject), /* tp_basicsize */
1913 : 0, /* tp_itemsize */
1914 : (destructor)SwigPyObject_dealloc, /* tp_dealloc */
1915 : 0, /* tp_print */
1916 : #if PY_VERSION_HEX < 0x02020000
1917 : (getattrfunc)SwigPyObject_getattr, /* tp_getattr */
1918 : #else
1919 : (getattrfunc)0, /* tp_getattr */
1920 : #endif
1921 : (setattrfunc)0, /* tp_setattr */
1922 : #if PY_VERSION_HEX >= 0x03000000
1923 : 0, /* tp_reserved in 3.0.1, tp_compare in 3.0.0 but not used */
1924 : #else
1925 : (cmpfunc)SwigPyObject_compare, /* tp_compare */
1926 : #endif
1927 : (reprfunc)SwigPyObject_repr, /* tp_repr */
1928 : &SwigPyObject_as_number, /* tp_as_number */
1929 : 0, /* tp_as_sequence */
1930 : 0, /* tp_as_mapping */
1931 : (hashfunc)0, /* tp_hash */
1932 : (ternaryfunc)0, /* tp_call */
1933 : 0, /* tp_str */
1934 : PyObject_GenericGetAttr, /* tp_getattro */
1935 : 0, /* tp_setattro */
1936 : 0, /* tp_as_buffer */
1937 : Py_TPFLAGS_DEFAULT, /* tp_flags */
1938 : swigobject_doc, /* tp_doc */
1939 : 0, /* tp_traverse */
1940 : 0, /* tp_clear */
1941 : (richcmpfunc)SwigPyObject_richcompare,/* tp_richcompare */
1942 : 0, /* tp_weaklistoffset */
1943 : #if PY_VERSION_HEX >= 0x02020000
1944 : 0, /* tp_iter */
1945 : 0, /* tp_iternext */
1946 : swigobject_methods, /* tp_methods */
1947 : 0, /* tp_members */
1948 : 0, /* tp_getset */
1949 : 0, /* tp_base */
1950 : 0, /* tp_dict */
1951 : 0, /* tp_descr_get */
1952 : 0, /* tp_descr_set */
1953 : 0, /* tp_dictoffset */
1954 : 0, /* tp_init */
1955 : 0, /* tp_alloc */
1956 : 0, /* tp_new */
1957 : 0, /* tp_free */
1958 : 0, /* tp_is_gc */
1959 : 0, /* tp_bases */
1960 : 0, /* tp_mro */
1961 : 0, /* tp_cache */
1962 : 0, /* tp_subclasses */
1963 : 0, /* tp_weaklist */
1964 : #endif
1965 : #if PY_VERSION_HEX >= 0x02030000
1966 : 0, /* tp_del */
1967 : #endif
1968 : #if PY_VERSION_HEX >= 0x02060000
1969 : 0, /* tp_version_tag */
1970 : #endif
1971 : #if PY_VERSION_HEX >= 0x03040000
1972 : 0, /* tp_finalize */
1973 : #endif
1974 : #ifdef COUNT_ALLOCS
1975 : 0, /* tp_allocs */
1976 : 0, /* tp_frees */
1977 : 0, /* tp_maxalloc */
1978 : #if PY_VERSION_HEX >= 0x02050000
1979 : 0, /* tp_prev */
1980 : #endif
1981 : 0 /* tp_next */
1982 : #endif
1983 : };
1984 27 : swigpyobject_type = tmp;
1985 27 : type_init = 1;
1986 : #if PY_VERSION_HEX < 0x02020000
1987 : swigpyobject_type.ob_type = &PyType_Type;
1988 : #else
1989 27 : if (PyType_Ready(&swigpyobject_type) < 0)
1990 : return NULL;
1991 : #endif
1992 : }
1993 : return &swigpyobject_type;
1994 : }
1995 :
1996 : SWIGRUNTIME PyObject *
1997 1928 : SwigPyObject_New(void *ptr, swig_type_info *ty, int own)
1998 : {
1999 1928 : SwigPyObject *sobj = PyObject_NEW(SwigPyObject, SwigPyObject_type());
2000 1928 : if (sobj) {
2001 1928 : sobj->ptr = ptr;
2002 1928 : sobj->ty = ty;
2003 1928 : sobj->own = own;
2004 1928 : sobj->next = 0;
2005 : }
2006 1928 : return (PyObject *)sobj;
2007 : }
2008 :
2009 : /* -----------------------------------------------------------------------------
2010 : * Implements a simple Swig Packed type, and use it instead of string
2011 : * ----------------------------------------------------------------------------- */
2012 :
2013 : typedef struct {
2014 : PyObject_HEAD
2015 : void *pack;
2016 : swig_type_info *ty;
2017 : size_t size;
2018 : } SwigPyPacked;
2019 :
2020 : SWIGRUNTIME int
2021 0 : SwigPyPacked_print(SwigPyPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
2022 : {
2023 : char result[SWIG_BUFFER_SIZE];
2024 0 : fputs("<Swig Packed ", fp);
2025 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2026 0 : fputs("at ", fp);
2027 0 : fputs(result, fp);
2028 : }
2029 0 : fputs(v->ty->name,fp);
2030 0 : fputs(">", fp);
2031 0 : return 0;
2032 : }
2033 :
2034 : SWIGRUNTIME PyObject *
2035 0 : SwigPyPacked_repr(SwigPyPacked *v)
2036 : {
2037 : char result[SWIG_BUFFER_SIZE];
2038 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
2039 0 : return SWIG_Python_str_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
2040 : } else {
2041 0 : return SWIG_Python_str_FromFormat("<Swig Packed %s>", v->ty->name);
2042 : }
2043 : }
2044 :
2045 : SWIGRUNTIME PyObject *
2046 0 : SwigPyPacked_str(SwigPyPacked *v)
2047 : {
2048 : char result[SWIG_BUFFER_SIZE];
2049 0 : if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
2050 0 : return SWIG_Python_str_FromFormat("%s%s", result, v->ty->name);
2051 : } else {
2052 0 : return SWIG_Python_str_FromChar(v->ty->name);
2053 : }
2054 : }
2055 :
2056 : SWIGRUNTIME int
2057 0 : SwigPyPacked_compare(SwigPyPacked *v, SwigPyPacked *w)
2058 : {
2059 0 : size_t i = v->size;
2060 0 : size_t j = w->size;
2061 0 : int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
2062 0 : return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
2063 : }
2064 :
2065 : SWIGRUNTIME PyTypeObject* SwigPyPacked_TypeOnce(void);
2066 :
2067 : SWIGRUNTIME PyTypeObject*
2068 : SwigPyPacked_type(void) {
2069 0 : static PyTypeObject *SWIG_STATIC_POINTER(type) = SwigPyPacked_TypeOnce();
2070 0 : return type;
2071 : }
2072 :
2073 : SWIGRUNTIMEINLINE int
2074 0 : SwigPyPacked_Check(PyObject *op) {
2075 0 : return ((op)->ob_type == SwigPyPacked_TypeOnce())
2076 0 : || (strcmp((op)->ob_type->tp_name,"SwigPyPacked") == 0);
2077 : }
2078 :
2079 : SWIGRUNTIME void
2080 0 : SwigPyPacked_dealloc(PyObject *v)
2081 : {
2082 0 : if (SwigPyPacked_Check(v)) {
2083 0 : SwigPyPacked *sobj = (SwigPyPacked *) v;
2084 0 : free(sobj->pack);
2085 : }
2086 0 : PyObject_DEL(v);
2087 0 : }
2088 :
2089 : SWIGRUNTIME PyTypeObject*
2090 0 : SwigPyPacked_TypeOnce(void) {
2091 : static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
2092 : static PyTypeObject swigpypacked_type;
2093 : static int type_init = 0;
2094 0 : if (!type_init) {
2095 : const PyTypeObject tmp = {
2096 : /* PyObject header changed in Python 3 */
2097 : #if PY_VERSION_HEX>=0x03000000
2098 : PyVarObject_HEAD_INIT(NULL, 0)
2099 : #else
2100 : PyObject_HEAD_INIT(NULL)
2101 : 0, /* ob_size */
2102 : #endif
2103 : (char *)"SwigPyPacked", /* tp_name */
2104 : sizeof(SwigPyPacked), /* tp_basicsize */
2105 : 0, /* tp_itemsize */
2106 : (destructor)SwigPyPacked_dealloc, /* tp_dealloc */
2107 : (printfunc)SwigPyPacked_print, /* tp_print */
2108 : (getattrfunc)0, /* tp_getattr */
2109 : (setattrfunc)0, /* tp_setattr */
2110 : #if PY_VERSION_HEX>=0x03000000
2111 : 0, /* tp_reserved in 3.0.1 */
2112 : #else
2113 : (cmpfunc)SwigPyPacked_compare, /* tp_compare */
2114 : #endif
2115 : (reprfunc)SwigPyPacked_repr, /* tp_repr */
2116 : 0, /* tp_as_number */
2117 : 0, /* tp_as_sequence */
2118 : 0, /* tp_as_mapping */
2119 : (hashfunc)0, /* tp_hash */
2120 : (ternaryfunc)0, /* tp_call */
2121 : (reprfunc)SwigPyPacked_str, /* tp_str */
2122 : PyObject_GenericGetAttr, /* tp_getattro */
2123 : 0, /* tp_setattro */
2124 : 0, /* tp_as_buffer */
2125 : Py_TPFLAGS_DEFAULT, /* tp_flags */
2126 : swigpacked_doc, /* tp_doc */
2127 : 0, /* tp_traverse */
2128 : 0, /* tp_clear */
2129 : 0, /* tp_richcompare */
2130 : 0, /* tp_weaklistoffset */
2131 : #if PY_VERSION_HEX >= 0x02020000
2132 : 0, /* tp_iter */
2133 : 0, /* tp_iternext */
2134 : 0, /* tp_methods */
2135 : 0, /* tp_members */
2136 : 0, /* tp_getset */
2137 : 0, /* tp_base */
2138 : 0, /* tp_dict */
2139 : 0, /* tp_descr_get */
2140 : 0, /* tp_descr_set */
2141 : 0, /* tp_dictoffset */
2142 : 0, /* tp_init */
2143 : 0, /* tp_alloc */
2144 : 0, /* tp_new */
2145 : 0, /* tp_free */
2146 : 0, /* tp_is_gc */
2147 : 0, /* tp_bases */
2148 : 0, /* tp_mro */
2149 : 0, /* tp_cache */
2150 : 0, /* tp_subclasses */
2151 : 0, /* tp_weaklist */
2152 : #endif
2153 : #if PY_VERSION_HEX >= 0x02030000
2154 : 0, /* tp_del */
2155 : #endif
2156 : #if PY_VERSION_HEX >= 0x02060000
2157 : 0, /* tp_version_tag */
2158 : #endif
2159 : #if PY_VERSION_HEX >= 0x03040000
2160 : 0, /* tp_finalize */
2161 : #endif
2162 : #ifdef COUNT_ALLOCS
2163 : 0, /* tp_allocs */
2164 : 0, /* tp_frees */
2165 : 0, /* tp_maxalloc */
2166 : #if PY_VERSION_HEX >= 0x02050000
2167 : 0, /* tp_prev */
2168 : #endif
2169 : 0 /* tp_next */
2170 : #endif
2171 : };
2172 0 : swigpypacked_type = tmp;
2173 0 : type_init = 1;
2174 : #if PY_VERSION_HEX < 0x02020000
2175 : swigpypacked_type.ob_type = &PyType_Type;
2176 : #else
2177 0 : if (PyType_Ready(&swigpypacked_type) < 0)
2178 : return NULL;
2179 : #endif
2180 : }
2181 : return &swigpypacked_type;
2182 : }
2183 :
2184 : SWIGRUNTIME PyObject *
2185 0 : SwigPyPacked_New(void *ptr, size_t size, swig_type_info *ty)
2186 : {
2187 0 : SwigPyPacked *sobj = PyObject_NEW(SwigPyPacked, SwigPyPacked_type());
2188 0 : if (sobj) {
2189 0 : void *pack = malloc(size);
2190 0 : if (pack) {
2191 0 : memcpy(pack, ptr, size);
2192 0 : sobj->pack = pack;
2193 0 : sobj->ty = ty;
2194 0 : sobj->size = size;
2195 : } else {
2196 0 : PyObject_DEL((PyObject *) sobj);
2197 0 : sobj = 0;
2198 : }
2199 : }
2200 0 : return (PyObject *) sobj;
2201 : }
2202 :
2203 : SWIGRUNTIME swig_type_info *
2204 : SwigPyPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
2205 : {
2206 : if (SwigPyPacked_Check(obj)) {
2207 : SwigPyPacked *sobj = (SwigPyPacked *)obj;
2208 : if (sobj->size != size) return 0;
2209 : memcpy(ptr, sobj->pack, size);
2210 : return sobj->ty;
2211 : } else {
2212 : return 0;
2213 : }
2214 : }
2215 :
2216 : /* -----------------------------------------------------------------------------
2217 : * pointers/data manipulation
2218 : * ----------------------------------------------------------------------------- */
2219 :
2220 : SWIGRUNTIMEINLINE PyObject *
2221 : _SWIG_This(void)
2222 : {
2223 27 : return SWIG_Python_str_FromChar("this");
2224 : }
2225 :
2226 : static PyObject *swig_this = NULL;
2227 :
2228 : SWIGRUNTIME PyObject *
2229 : SWIG_This(void)
2230 : {
2231 6370 : if (swig_this == NULL)
2232 27 : swig_this = _SWIG_This();
2233 6370 : return swig_this;
2234 : }
2235 :
2236 : /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
2237 :
2238 : /* TODO: I don't know how to implement the fast getset in Python 3 right now */
2239 : #if PY_VERSION_HEX>=0x03000000
2240 : #define SWIG_PYTHON_SLOW_GETSET_THIS
2241 : #endif
2242 :
2243 : SWIGRUNTIME SwigPyObject *
2244 7552 : SWIG_Python_GetSwigThis(PyObject *pyobj)
2245 : {
2246 : PyObject *obj;
2247 :
2248 7552 : if (SwigPyObject_Check(pyobj))
2249 : return (SwigPyObject *) pyobj;
2250 :
2251 : #ifdef SWIGPYTHON_BUILTIN
2252 : (void)obj;
2253 : # ifdef PyWeakref_CheckProxy
2254 : if (PyWeakref_CheckProxy(pyobj)) {
2255 : pyobj = PyWeakref_GET_OBJECT(pyobj);
2256 : if (pyobj && SwigPyObject_Check(pyobj))
2257 : return (SwigPyObject*) pyobj;
2258 : }
2259 : # endif
2260 : return NULL;
2261 : #else
2262 :
2263 4916 : obj = 0;
2264 :
2265 : #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
2266 4916 : if (PyInstance_Check(pyobj)) {
2267 0 : obj = _PyInstance_Lookup(pyobj, SWIG_This());
2268 : } else {
2269 4916 : PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
2270 4916 : if (dictptr != NULL) {
2271 4916 : PyObject *dict = *dictptr;
2272 9832 : obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
2273 : } else {
2274 : #ifdef PyWeakref_CheckProxy
2275 0 : if (PyWeakref_CheckProxy(pyobj)) {
2276 0 : PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
2277 0 : return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
2278 : }
2279 : #endif
2280 0 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2281 0 : if (obj) {
2282 0 : Py_DECREF(obj);
2283 : } else {
2284 0 : if (PyErr_Occurred()) PyErr_Clear();
2285 : return 0;
2286 : }
2287 : }
2288 : }
2289 : #else
2290 : obj = PyObject_GetAttr(pyobj,SWIG_This());
2291 : if (obj) {
2292 : Py_DECREF(obj);
2293 : } else {
2294 : if (PyErr_Occurred()) PyErr_Clear();
2295 : return 0;
2296 : }
2297 : #endif
2298 4916 : if (obj && !SwigPyObject_Check(obj)) {
2299 : /* a PyObject is called 'this', try to get the 'real this'
2300 : SwigPyObject from it */
2301 : return SWIG_Python_GetSwigThis(obj);
2302 : }
2303 : return (SwigPyObject *)obj;
2304 : #endif
2305 : }
2306 :
2307 : /* Acquire a pointer value */
2308 :
2309 : SWIGRUNTIME int
2310 : SWIG_Python_AcquirePtr(PyObject *obj, int own) {
2311 : if (own == SWIG_POINTER_OWN) {
2312 : SwigPyObject *sobj = SWIG_Python_GetSwigThis(obj);
2313 : if (sobj) {
2314 : int oldown = sobj->own;
2315 : sobj->own = own;
2316 : return oldown;
2317 : }
2318 : }
2319 : return 0;
2320 : }
2321 :
2322 : /* Convert a pointer value */
2323 :
2324 : SWIGRUNTIME int
2325 7640 : SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
2326 : int res;
2327 : SwigPyObject *sobj;
2328 7640 : int implicit_conv = (flags & SWIG_POINTER_IMPLICIT_CONV) != 0;
2329 :
2330 7640 : if (!obj)
2331 : return SWIG_ERROR;
2332 7640 : if (obj == Py_None && !implicit_conv) {
2333 88 : if (ptr)
2334 88 : *ptr = 0;
2335 : return SWIG_OK;
2336 : }
2337 :
2338 7552 : res = SWIG_ERROR;
2339 :
2340 7552 : sobj = SWIG_Python_GetSwigThis(obj);
2341 7552 : if (own)
2342 0 : *own = 0;
2343 7552 : while (sobj) {
2344 7552 : void *vptr = sobj->ptr;
2345 7552 : if (ty) {
2346 7552 : swig_type_info *to = sobj->ty;
2347 7552 : if (to == ty) {
2348 : /* no type cast needed */
2349 7552 : if (ptr) *ptr = vptr;
2350 : break;
2351 : } else {
2352 0 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2353 0 : if (!tc) {
2354 0 : sobj = (SwigPyObject *)sobj->next;
2355 : } else {
2356 0 : if (ptr) {
2357 0 : int newmemory = 0;
2358 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2359 0 : if (newmemory == SWIG_CAST_NEW_MEMORY) {
2360 : assert(own); /* badly formed typemap which will lead to a memory leak - it must set and use own to delete *ptr */
2361 0 : if (own)
2362 0 : *own = *own | SWIG_CAST_NEW_MEMORY;
2363 : }
2364 : }
2365 : break;
2366 : }
2367 : }
2368 : } else {
2369 0 : if (ptr) *ptr = vptr;
2370 : break;
2371 : }
2372 : }
2373 7552 : if (sobj) {
2374 7552 : if (own)
2375 0 : *own = *own | sobj->own;
2376 7552 : if (flags & SWIG_POINTER_DISOWN) {
2377 0 : sobj->own = 0;
2378 : }
2379 : res = SWIG_OK;
2380 : } else {
2381 0 : if (implicit_conv) {
2382 0 : SwigPyClientData *data = ty ? (SwigPyClientData *) ty->clientdata : 0;
2383 0 : if (data && !data->implicitconv) {
2384 0 : PyObject *klass = data->klass;
2385 0 : if (klass) {
2386 : PyObject *impconv;
2387 0 : data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2388 0 : impconv = SWIG_Python_CallFunctor(klass, obj);
2389 0 : data->implicitconv = 0;
2390 0 : if (PyErr_Occurred()) {
2391 0 : PyErr_Clear();
2392 0 : impconv = 0;
2393 : }
2394 0 : if (impconv) {
2395 0 : SwigPyObject *iobj = SWIG_Python_GetSwigThis(impconv);
2396 0 : if (iobj) {
2397 : void *vptr;
2398 0 : res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2399 0 : if (SWIG_IsOK(res)) {
2400 0 : if (ptr) {
2401 0 : *ptr = vptr;
2402 : /* transfer the ownership to 'ptr' */
2403 0 : iobj->own = 0;
2404 0 : res = SWIG_AddCast(res);
2405 0 : res = SWIG_AddNewMask(res);
2406 : } else {
2407 : res = SWIG_AddCast(res);
2408 : }
2409 : }
2410 : }
2411 0 : Py_DECREF(impconv);
2412 : }
2413 : }
2414 : }
2415 : }
2416 0 : if (!SWIG_IsOK(res) && obj == Py_None) {
2417 0 : if (ptr)
2418 0 : *ptr = 0;
2419 0 : if (PyErr_Occurred())
2420 0 : PyErr_Clear();
2421 : res = SWIG_OK;
2422 : }
2423 : }
2424 : return res;
2425 : }
2426 :
2427 : /* Convert a function ptr value */
2428 :
2429 : SWIGRUNTIME int
2430 0 : SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2431 0 : if (!PyCFunction_Check(obj)) {
2432 0 : return SWIG_ConvertPtr(obj, ptr, ty, 0);
2433 : } else {
2434 0 : void *vptr = 0;
2435 :
2436 : /* here we get the method pointer for callbacks */
2437 0 : const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2438 0 : const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2439 0 : if (desc)
2440 0 : desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2441 0 : if (!desc)
2442 : return SWIG_ERROR;
2443 0 : if (ty) {
2444 0 : swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2445 0 : if (tc) {
2446 0 : int newmemory = 0;
2447 0 : *ptr = SWIG_TypeCast(tc,vptr,&newmemory);
2448 : assert(!newmemory); /* newmemory handling not yet implemented */
2449 : } else {
2450 : return SWIG_ERROR;
2451 : }
2452 : } else {
2453 0 : *ptr = vptr;
2454 : }
2455 : return SWIG_OK;
2456 : }
2457 : }
2458 :
2459 : /* Convert a packed value value */
2460 :
2461 : SWIGRUNTIME int
2462 : SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2463 : swig_type_info *to = SwigPyPacked_UnpackData(obj, ptr, sz);
2464 : if (!to) return SWIG_ERROR;
2465 : if (ty) {
2466 : if (to != ty) {
2467 : /* check type cast? */
2468 : swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2469 : if (!tc) return SWIG_ERROR;
2470 : }
2471 : }
2472 : return SWIG_OK;
2473 : }
2474 :
2475 : /* -----------------------------------------------------------------------------
2476 : * Create a new pointer object
2477 : * ----------------------------------------------------------------------------- */
2478 :
2479 : /*
2480 : Create a new instance object, without calling __init__, and set the
2481 : 'this' attribute.
2482 : */
2483 :
2484 : SWIGRUNTIME PyObject*
2485 1375 : SWIG_Python_NewShadowInstance(SwigPyClientData *data, PyObject *swig_this)
2486 : {
2487 : #if (PY_VERSION_HEX >= 0x02020000)
2488 1375 : PyObject *inst = 0;
2489 1375 : PyObject *newraw = data->newraw;
2490 1375 : if (newraw) {
2491 1375 : inst = PyObject_Call(newraw, data->newargs, NULL);
2492 1375 : if (inst) {
2493 : #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2494 1375 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2495 1375 : if (dictptr != NULL) {
2496 1375 : PyObject *dict = *dictptr;
2497 1375 : if (dict == NULL) {
2498 1375 : dict = PyDict_New();
2499 1375 : *dictptr = dict;
2500 1375 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2501 : }
2502 : }
2503 : #else
2504 : PyObject *key = SWIG_This();
2505 : PyObject_SetAttr(inst, key, swig_this);
2506 : #endif
2507 : }
2508 : } else {
2509 : #if PY_VERSION_HEX >= 0x03000000
2510 : inst = ((PyTypeObject*) data->newargs)->tp_new((PyTypeObject*) data->newargs, Py_None, Py_None);
2511 : if (inst) {
2512 : PyObject_SetAttr(inst, SWIG_This(), swig_this);
2513 : Py_TYPE(inst)->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
2514 : }
2515 : #else
2516 0 : PyObject *dict = PyDict_New();
2517 0 : if (dict) {
2518 0 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2519 0 : inst = PyInstance_NewRaw(data->newargs, dict);
2520 0 : Py_DECREF(dict);
2521 : }
2522 : #endif
2523 : }
2524 1375 : return inst;
2525 : #else
2526 : #if (PY_VERSION_HEX >= 0x02010000)
2527 : PyObject *inst = 0;
2528 : PyObject *dict = PyDict_New();
2529 : if (dict) {
2530 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2531 : inst = PyInstance_NewRaw(data->newargs, dict);
2532 : Py_DECREF(dict);
2533 : }
2534 : return (PyObject *) inst;
2535 : #else
2536 : PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2537 : if (inst == NULL) {
2538 : return NULL;
2539 : }
2540 : inst->in_class = (PyClassObject *)data->newargs;
2541 : Py_INCREF(inst->in_class);
2542 : inst->in_dict = PyDict_New();
2543 : if (inst->in_dict == NULL) {
2544 : Py_DECREF(inst);
2545 : return NULL;
2546 : }
2547 : #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2548 : inst->in_weakreflist = NULL;
2549 : #endif
2550 : #ifdef Py_TPFLAGS_GC
2551 : PyObject_GC_Init(inst);
2552 : #endif
2553 : PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2554 : return (PyObject *) inst;
2555 : #endif
2556 : #endif
2557 : }
2558 :
2559 : SWIGRUNTIME void
2560 : SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2561 : {
2562 : PyObject *dict;
2563 : #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2564 : PyObject **dictptr = _PyObject_GetDictPtr(inst);
2565 : if (dictptr != NULL) {
2566 : dict = *dictptr;
2567 : if (dict == NULL) {
2568 : dict = PyDict_New();
2569 : *dictptr = dict;
2570 : }
2571 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2572 : return;
2573 : }
2574 : #endif
2575 : dict = PyObject_GetAttrString(inst, (char*)"__dict__");
2576 : PyDict_SetItem(dict, SWIG_This(), swig_this);
2577 : Py_DECREF(dict);
2578 : }
2579 :
2580 :
2581 : SWIGINTERN PyObject *
2582 : SWIG_Python_InitShadowInstance(PyObject *args) {
2583 : PyObject *obj[2];
2584 : if (!SWIG_Python_UnpackTuple(args, "swiginit", 2, 2, obj)) {
2585 : return NULL;
2586 : } else {
2587 : SwigPyObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2588 : if (sthis) {
2589 : SwigPyObject_append((PyObject*) sthis, obj[1]);
2590 : } else {
2591 : SWIG_Python_SetSwigThis(obj[0], obj[1]);
2592 : }
2593 : return SWIG_Py_Void();
2594 : }
2595 : }
2596 :
2597 : /* Create a new pointer object */
2598 :
2599 : SWIGRUNTIME PyObject *
2600 2017 : SWIG_Python_NewPointerObj(PyObject *self, void *ptr, swig_type_info *type, int flags) {
2601 : SwigPyClientData *clientdata;
2602 : PyObject * robj;
2603 : int own;
2604 :
2605 2017 : if (!ptr)
2606 89 : return SWIG_Py_Void();
2607 :
2608 1928 : clientdata = type ? (SwigPyClientData *)(type->clientdata) : 0;
2609 1928 : own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2610 1928 : if (clientdata && clientdata->pytype) {
2611 : SwigPyObject *newobj;
2612 0 : if (flags & SWIG_BUILTIN_TP_INIT) {
2613 0 : newobj = (SwigPyObject*) self;
2614 0 : if (newobj->ptr) {
2615 0 : PyObject *next_self = clientdata->pytype->tp_alloc(clientdata->pytype, 0);
2616 0 : while (newobj->next)
2617 : newobj = (SwigPyObject *) newobj->next;
2618 0 : newobj->next = next_self;
2619 0 : newobj = (SwigPyObject *)next_self;
2620 : #ifdef SWIGPYTHON_BUILTIN
2621 : newobj->dict = 0;
2622 : #endif
2623 : }
2624 : } else {
2625 0 : newobj = PyObject_New(SwigPyObject, clientdata->pytype);
2626 : #ifdef SWIGPYTHON_BUILTIN
2627 : newobj->dict = 0;
2628 : #endif
2629 : }
2630 0 : if (newobj) {
2631 0 : newobj->ptr = ptr;
2632 0 : newobj->ty = type;
2633 0 : newobj->own = own;
2634 0 : newobj->next = 0;
2635 0 : return (PyObject*) newobj;
2636 : }
2637 0 : return SWIG_Py_Void();
2638 : }
2639 :
2640 : assert(!(flags & SWIG_BUILTIN_TP_INIT));
2641 :
2642 1928 : robj = SwigPyObject_New(ptr, type, own);
2643 1928 : if (robj && clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2644 1375 : PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2645 1375 : Py_DECREF(robj);
2646 : robj = inst;
2647 : }
2648 : return robj;
2649 : }
2650 :
2651 : /* Create a new packed object */
2652 :
2653 : SWIGRUNTIMEINLINE PyObject *
2654 : SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2655 0 : return ptr ? SwigPyPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2656 : }
2657 :
2658 : /* -----------------------------------------------------------------------------*
2659 : * Get type list
2660 : * -----------------------------------------------------------------------------*/
2661 :
2662 : #ifdef SWIG_LINK_RUNTIME
2663 : void *SWIG_ReturnGlobalTypeList(void *);
2664 : #endif
2665 :
2666 : SWIGRUNTIME swig_module_info *
2667 27 : SWIG_Python_GetModule(void *SWIGUNUSEDPARM(clientdata)) {
2668 : static void *type_pointer = (void *)0;
2669 : /* first check if module already created */
2670 27 : if (!type_pointer) {
2671 : #ifdef SWIG_LINK_RUNTIME
2672 : type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2673 : #else
2674 : # ifdef SWIGPY_USE_CAPSULE
2675 27 : type_pointer = PyCapsule_Import(SWIGPY_CAPSULE_NAME, 0);
2676 : # else
2677 : type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2678 : (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2679 : # endif
2680 27 : if (PyErr_Occurred()) {
2681 27 : PyErr_Clear();
2682 27 : type_pointer = (void *)0;
2683 : }
2684 : #endif
2685 : }
2686 27 : return (swig_module_info *) type_pointer;
2687 : }
2688 :
2689 : #if PY_MAJOR_VERSION < 2
2690 : /* PyModule_AddObject function was introduced in Python 2.0. The following function
2691 : is copied out of Python/modsupport.c in python version 2.3.4 */
2692 : SWIGINTERN int
2693 : PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2694 : {
2695 : PyObject *dict;
2696 : if (!PyModule_Check(m)) {
2697 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs module as first arg");
2698 : return SWIG_ERROR;
2699 : }
2700 : if (!o) {
2701 : PyErr_SetString(PyExc_TypeError, "PyModule_AddObject() needs non-NULL value");
2702 : return SWIG_ERROR;
2703 : }
2704 :
2705 : dict = PyModule_GetDict(m);
2706 : if (dict == NULL) {
2707 : /* Internal error -- modules must have a dict! */
2708 : PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2709 : PyModule_GetName(m));
2710 : return SWIG_ERROR;
2711 : }
2712 : if (PyDict_SetItemString(dict, name, o))
2713 : return SWIG_ERROR;
2714 : Py_DECREF(o);
2715 : return SWIG_OK;
2716 : }
2717 : #endif
2718 :
2719 : SWIGRUNTIME void
2720 : #ifdef SWIGPY_USE_CAPSULE
2721 27 : SWIG_Python_DestroyModule(PyObject *obj)
2722 : #else
2723 : SWIG_Python_DestroyModule(void *vptr)
2724 : #endif
2725 : {
2726 : #ifdef SWIGPY_USE_CAPSULE
2727 27 : swig_module_info *swig_module = (swig_module_info *) PyCapsule_GetPointer(obj, SWIGPY_CAPSULE_NAME);
2728 : #else
2729 : swig_module_info *swig_module = (swig_module_info *) vptr;
2730 : #endif
2731 27 : swig_type_info **types = swig_module->types;
2732 : size_t i;
2733 2322 : for (i =0; i < swig_module->size; ++i) {
2734 2295 : swig_type_info *ty = types[i];
2735 2295 : if (ty->owndata) {
2736 810 : SwigPyClientData *data = (SwigPyClientData *) ty->clientdata;
2737 810 : if (data) SwigPyClientData_Del(data);
2738 : }
2739 : }
2740 79 : Py_DECREF(SWIG_This());
2741 27 : swig_this = NULL;
2742 27 : }
2743 :
2744 : SWIGRUNTIME void
2745 27 : SWIG_Python_SetModule(swig_module_info *swig_module) {
2746 : #if PY_VERSION_HEX >= 0x03000000
2747 : /* Add a dummy module object into sys.modules */
2748 : PyObject *module = PyImport_AddModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION);
2749 : #else
2750 : static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} }; /* Sentinel */
2751 27 : PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION, swig_empty_runtime_method_table);
2752 : #endif
2753 : #ifdef SWIGPY_USE_CAPSULE
2754 27 : PyObject *pointer = PyCapsule_New((void *) swig_module, SWIGPY_CAPSULE_NAME, SWIG_Python_DestroyModule);
2755 27 : if (pointer && module) {
2756 27 : PyModule_AddObject(module, (char*)"type_pointer_capsule" SWIG_TYPE_TABLE_NAME, pointer);
2757 : } else {
2758 0 : Py_XDECREF(pointer);
2759 : }
2760 : #else
2761 : PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2762 : if (pointer && module) {
2763 : PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2764 : } else {
2765 : Py_XDECREF(pointer);
2766 : }
2767 : #endif
2768 27 : }
2769 :
2770 : /* The python cached type query */
2771 : SWIGRUNTIME PyObject *
2772 : SWIG_Python_TypeCache(void) {
2773 : static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2774 : return cache;
2775 : }
2776 :
2777 : SWIGRUNTIME swig_type_info *
2778 : SWIG_Python_TypeQuery(const char *type)
2779 : {
2780 : PyObject *cache = SWIG_Python_TypeCache();
2781 : PyObject *key = SWIG_Python_str_FromChar(type);
2782 : PyObject *obj = PyDict_GetItem(cache, key);
2783 : swig_type_info *descriptor;
2784 : if (obj) {
2785 : #ifdef SWIGPY_USE_CAPSULE
2786 : descriptor = (swig_type_info *) PyCapsule_GetPointer(obj, NULL);
2787 : #else
2788 : descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2789 : #endif
2790 : } else {
2791 : swig_module_info *swig_module = SWIG_GetModule(0);
2792 : descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2793 : if (descriptor) {
2794 : #ifdef SWIGPY_USE_CAPSULE
2795 : obj = PyCapsule_New((void*) descriptor, NULL, NULL);
2796 : #else
2797 : obj = PyCObject_FromVoidPtr(descriptor, NULL);
2798 : #endif
2799 : PyDict_SetItem(cache, key, obj);
2800 : Py_DECREF(obj);
2801 : }
2802 : }
2803 : Py_DECREF(key);
2804 : return descriptor;
2805 : }
2806 :
2807 : /*
2808 : For backward compatibility only
2809 : */
2810 : #define SWIG_POINTER_EXCEPTION 0
2811 : #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2812 : #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2813 :
2814 : SWIGRUNTIME int
2815 : SWIG_Python_AddErrMesg(const char* mesg, int infront)
2816 : {
2817 : if (PyErr_Occurred()) {
2818 : PyObject *type = 0;
2819 : PyObject *value = 0;
2820 : PyObject *traceback = 0;
2821 : PyErr_Fetch(&type, &value, &traceback);
2822 : if (value) {
2823 : char *tmp;
2824 : PyObject *old_str = PyObject_Str(value);
2825 : Py_XINCREF(type);
2826 : PyErr_Clear();
2827 : if (infront) {
2828 : PyErr_Format(type, "%s %s", mesg, tmp = SWIG_Python_str_AsChar(old_str));
2829 : } else {
2830 : PyErr_Format(type, "%s %s", tmp = SWIG_Python_str_AsChar(old_str), mesg);
2831 : }
2832 : SWIG_Python_str_DelForPy3(tmp);
2833 : Py_DECREF(old_str);
2834 : }
2835 : return 1;
2836 : } else {
2837 : return 0;
2838 : }
2839 : }
2840 :
2841 : SWIGRUNTIME int
2842 : SWIG_Python_ArgFail(int argnum)
2843 : {
2844 : if (PyErr_Occurred()) {
2845 : /* add information about failing argument */
2846 : char mesg[256];
2847 : PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2848 : return SWIG_Python_AddErrMesg(mesg, 1);
2849 : } else {
2850 : return 0;
2851 : }
2852 : }
2853 :
2854 : SWIGRUNTIMEINLINE const char *
2855 : SwigPyObject_GetDesc(PyObject *self)
2856 : {
2857 : SwigPyObject *v = (SwigPyObject *)self;
2858 : swig_type_info *ty = v ? v->ty : 0;
2859 : return ty ? ty->str : "";
2860 : }
2861 :
2862 : SWIGRUNTIME void
2863 : SWIG_Python_TypeError(const char *type, PyObject *obj)
2864 : {
2865 : if (type) {
2866 : #if defined(SWIG_COBJECT_TYPES)
2867 : if (obj && SwigPyObject_Check(obj)) {
2868 : const char *otype = (const char *) SwigPyObject_GetDesc(obj);
2869 : if (otype) {
2870 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'SwigPyObject(%s)' is received",
2871 : type, otype);
2872 : return;
2873 : }
2874 : } else
2875 : #endif
2876 : {
2877 : const char *otype = (obj ? obj->ob_type->tp_name : 0);
2878 : if (otype) {
2879 : PyObject *str = PyObject_Str(obj);
2880 : const char *cstr = str ? SWIG_Python_str_AsChar(str) : 0;
2881 : if (cstr) {
2882 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2883 : type, otype, cstr);
2884 : SWIG_Python_str_DelForPy3(cstr);
2885 : } else {
2886 : PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2887 : type, otype);
2888 : }
2889 : Py_XDECREF(str);
2890 : return;
2891 : }
2892 : }
2893 : PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2894 : } else {
2895 : PyErr_Format(PyExc_TypeError, "unexpected type is received");
2896 : }
2897 : }
2898 :
2899 :
2900 : /* Convert a pointer value, signal an exception on a type mismatch */
2901 : SWIGRUNTIME void *
2902 : SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int SWIGUNUSEDPARM(argnum), int flags) {
2903 : void *result;
2904 : if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2905 : PyErr_Clear();
2906 : #if SWIG_POINTER_EXCEPTION
2907 : if (flags) {
2908 : SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2909 : SWIG_Python_ArgFail(argnum);
2910 : }
2911 : #endif
2912 : }
2913 : return result;
2914 : }
2915 :
2916 : #ifdef SWIGPYTHON_BUILTIN
2917 : SWIGRUNTIME int
2918 : SWIG_Python_NonDynamicSetAttr(PyObject *obj, PyObject *name, PyObject *value) {
2919 : PyTypeObject *tp = obj->ob_type;
2920 : PyObject *descr;
2921 : PyObject *encoded_name;
2922 : descrsetfunc f;
2923 : int res = -1;
2924 :
2925 : # ifdef Py_USING_UNICODE
2926 : if (PyString_Check(name)) {
2927 : name = PyUnicode_Decode(PyString_AsString(name), PyString_Size(name), NULL, NULL);
2928 : if (!name)
2929 : return -1;
2930 : } else if (!PyUnicode_Check(name))
2931 : # else
2932 : if (!PyString_Check(name))
2933 : # endif
2934 : {
2935 : PyErr_Format(PyExc_TypeError, "attribute name must be string, not '%.200s'", name->ob_type->tp_name);
2936 : return -1;
2937 : } else {
2938 : Py_INCREF(name);
2939 : }
2940 :
2941 : if (!tp->tp_dict) {
2942 : if (PyType_Ready(tp) < 0)
2943 : goto done;
2944 : }
2945 :
2946 : descr = _PyType_Lookup(tp, name);
2947 : f = NULL;
2948 : if (descr != NULL)
2949 : f = descr->ob_type->tp_descr_set;
2950 : if (!f) {
2951 : if (PyString_Check(name)) {
2952 : encoded_name = name;
2953 : Py_INCREF(name);
2954 : } else {
2955 : encoded_name = PyUnicode_AsUTF8String(name);
2956 : }
2957 : PyErr_Format(PyExc_AttributeError, "'%.100s' object has no attribute '%.200s'", tp->tp_name, PyString_AsString(encoded_name));
2958 : Py_DECREF(encoded_name);
2959 : } else {
2960 : res = f(descr, obj, value);
2961 : }
2962 :
2963 : done:
2964 : Py_DECREF(name);
2965 : return res;
2966 : }
2967 : #endif
2968 :
2969 :
2970 : #ifdef __cplusplus
2971 : }
2972 : #endif
2973 :
2974 :
2975 :
2976 : #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2977 :
2978 : #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2979 :
2980 :
2981 :
2982 : /* -------- TYPES TABLE (BEGIN) -------- */
2983 :
2984 : #define SWIGTYPE_p_FILE swig_types[0]
2985 : #define SWIGTYPE_p__gpgme_attr_t swig_types[1]
2986 : #define SWIGTYPE_p__gpgme_engine_info swig_types[2]
2987 : #define SWIGTYPE_p__gpgme_import_status swig_types[3]
2988 : #define SWIGTYPE_p__gpgme_invalid_key swig_types[4]
2989 : #define SWIGTYPE_p__gpgme_key swig_types[5]
2990 : #define SWIGTYPE_p__gpgme_key_sig swig_types[6]
2991 : #define SWIGTYPE_p__gpgme_new_signature swig_types[7]
2992 : #define SWIGTYPE_p__gpgme_op_assuan_result swig_types[8]
2993 : #define SWIGTYPE_p__gpgme_op_decrypt_result swig_types[9]
2994 : #define SWIGTYPE_p__gpgme_op_encrypt_result swig_types[10]
2995 : #define SWIGTYPE_p__gpgme_op_genkey_result swig_types[11]
2996 : #define SWIGTYPE_p__gpgme_op_import_result swig_types[12]
2997 : #define SWIGTYPE_p__gpgme_op_keylist_result swig_types[13]
2998 : #define SWIGTYPE_p__gpgme_op_query_swdb_result swig_types[14]
2999 : #define SWIGTYPE_p__gpgme_op_sign_result swig_types[15]
3000 : #define SWIGTYPE_p__gpgme_op_verify_result swig_types[16]
3001 : #define SWIGTYPE_p__gpgme_op_vfs_mount_result swig_types[17]
3002 : #define SWIGTYPE_p__gpgme_recipient swig_types[18]
3003 : #define SWIGTYPE_p__gpgme_sig_notation swig_types[19]
3004 : #define SWIGTYPE_p__gpgme_sig_stat_t swig_types[20]
3005 : #define SWIGTYPE_p__gpgme_signature swig_types[21]
3006 : #define SWIGTYPE_p__gpgme_subkey swig_types[22]
3007 : #define SWIGTYPE_p__gpgme_tofu_info swig_types[23]
3008 : #define SWIGTYPE_p__gpgme_trust_item swig_types[24]
3009 : #define SWIGTYPE_p__gpgme_user_id swig_types[25]
3010 : #define SWIGTYPE_p_a___p__gpgme_key swig_types[26]
3011 : #define SWIGTYPE_p_char swig_types[27]
3012 : #define SWIGTYPE_p_f_p_void__void swig_types[28]
3013 : #define SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void swig_types[29]
3014 : #define SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t swig_types[30]
3015 : #define SWIGTYPE_p_f_p_void_off_t_int__off_t swig_types[31]
3016 : #define SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void swig_types[32]
3017 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[33]
3018 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t swig_types[34]
3019 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[35]
3020 : #define SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t swig_types[36]
3021 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__gpg_error_t swig_types[37]
3022 : #define SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t swig_types[38]
3023 : #define SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t swig_types[39]
3024 : #define SWIGTYPE_p_gpg_err_code_t swig_types[40]
3025 : #define SWIGTYPE_p_gpg_err_source_t swig_types[41]
3026 : #define SWIGTYPE_p_gpg_error_t swig_types[42]
3027 : #define SWIGTYPE_p_gpgme_conf_arg swig_types[43]
3028 : #define SWIGTYPE_p_gpgme_conf_arg_value swig_types[44]
3029 : #define SWIGTYPE_p_gpgme_conf_comp swig_types[45]
3030 : #define SWIGTYPE_p_gpgme_conf_level_t swig_types[46]
3031 : #define SWIGTYPE_p_gpgme_conf_opt swig_types[47]
3032 : #define SWIGTYPE_p_gpgme_conf_type_t swig_types[48]
3033 : #define SWIGTYPE_p_gpgme_context swig_types[49]
3034 : #define SWIGTYPE_p_gpgme_data swig_types[50]
3035 : #define SWIGTYPE_p_gpgme_data_cbs swig_types[51]
3036 : #define SWIGTYPE_p_gpgme_data_encoding_t swig_types[52]
3037 : #define SWIGTYPE_p_gpgme_data_type_t swig_types[53]
3038 : #define SWIGTYPE_p_gpgme_encrypt_flags_t swig_types[54]
3039 : #define SWIGTYPE_p_gpgme_event_io_t swig_types[55]
3040 : #define SWIGTYPE_p_gpgme_hash_algo_t swig_types[56]
3041 : #define SWIGTYPE_p_gpgme_io_cbs swig_types[57]
3042 : #define SWIGTYPE_p_gpgme_io_event_done_data swig_types[58]
3043 : #define SWIGTYPE_p_gpgme_pinentry_mode_t swig_types[59]
3044 : #define SWIGTYPE_p_gpgme_protocol_t swig_types[60]
3045 : #define SWIGTYPE_p_gpgme_pubkey_algo_t swig_types[61]
3046 : #define SWIGTYPE_p_gpgme_sig_mode_t swig_types[62]
3047 : #define SWIGTYPE_p_gpgme_sigsum_t swig_types[63]
3048 : #define SWIGTYPE_p_gpgme_status_code_t swig_types[64]
3049 : #define SWIGTYPE_p_gpgme_tofu_policy_t swig_types[65]
3050 : #define SWIGTYPE_p_gpgme_validity_t swig_types[66]
3051 : #define SWIGTYPE_p_off_t swig_types[67]
3052 : #define SWIGTYPE_p_p__gpgme_engine_info swig_types[68]
3053 : #define SWIGTYPE_p_p__gpgme_key swig_types[69]
3054 : #define SWIGTYPE_p_p__gpgme_trust_item swig_types[70]
3055 : #define SWIGTYPE_p_p_char swig_types[71]
3056 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void swig_types[72]
3057 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t swig_types[73]
3058 : #define SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t swig_types[74]
3059 : #define SWIGTYPE_p_p_gpgme_conf_arg swig_types[75]
3060 : #define SWIGTYPE_p_p_gpgme_conf_comp swig_types[76]
3061 : #define SWIGTYPE_p_p_gpgme_conf_opt swig_types[77]
3062 : #define SWIGTYPE_p_p_gpgme_context swig_types[78]
3063 : #define SWIGTYPE_p_p_gpgme_data swig_types[79]
3064 : #define SWIGTYPE_p_p_void swig_types[80]
3065 : #define SWIGTYPE_p_size_t swig_types[81]
3066 : #define SWIGTYPE_p_ssize_t swig_types[82]
3067 : #define SWIGTYPE_p_unsigned_int swig_types[83]
3068 : #define SWIGTYPE_p_void swig_types[84]
3069 : static swig_type_info *swig_types[86];
3070 : static swig_module_info swig_module = {swig_types, 85, 0, 0, 0, 0};
3071 : #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
3072 : #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
3073 :
3074 : /* -------- TYPES TABLE (END) -------- */
3075 :
3076 : #if (PY_VERSION_HEX <= 0x02000000)
3077 : # if !defined(SWIG_PYTHON_CLASSIC)
3078 : # error "This python version requires swig to be run with the '-classic' option"
3079 : # endif
3080 : #endif
3081 :
3082 : /*-----------------------------------------------
3083 : @(target):= _gpgme.so
3084 : ------------------------------------------------*/
3085 : #if PY_VERSION_HEX >= 0x03000000
3086 : # define SWIG_init PyInit__gpgme
3087 :
3088 : #else
3089 : # define SWIG_init init_gpgme
3090 :
3091 : #endif
3092 : #define SWIG_name "_gpgme"
3093 :
3094 : #define SWIGVERSION 0x030010
3095 : #define SWIG_VERSION SWIGVERSION
3096 :
3097 :
3098 : #define SWIG_as_voidptr(a) (void *)((const void *)(a))
3099 : #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
3100 :
3101 :
3102 : #include "data.h" /* For struct gpgme_data. */
3103 :
3104 :
3105 : #include <limits.h>
3106 : #if !defined(SWIG_NO_LLONG_MAX)
3107 : # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
3108 : # define LLONG_MAX __LONG_LONG_MAX__
3109 : # define LLONG_MIN (-LLONG_MAX - 1LL)
3110 : # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
3111 : # endif
3112 : #endif
3113 :
3114 :
3115 : SWIGINTERN int
3116 : SWIG_AsVal_double (PyObject *obj, double *val)
3117 : {
3118 : int res = SWIG_TypeError;
3119 : if (PyFloat_Check(obj)) {
3120 : if (val) *val = PyFloat_AsDouble(obj);
3121 : return SWIG_OK;
3122 : #if PY_VERSION_HEX < 0x03000000
3123 : } else if (PyInt_Check(obj)) {
3124 : if (val) *val = PyInt_AsLong(obj);
3125 : return SWIG_OK;
3126 : #endif
3127 : } else if (PyLong_Check(obj)) {
3128 : double v = PyLong_AsDouble(obj);
3129 : if (!PyErr_Occurred()) {
3130 : if (val) *val = v;
3131 : return SWIG_OK;
3132 : } else {
3133 : PyErr_Clear();
3134 : }
3135 : }
3136 : #ifdef SWIG_PYTHON_CAST_MODE
3137 : {
3138 : int dispatch = 0;
3139 : double d = PyFloat_AsDouble(obj);
3140 : if (!PyErr_Occurred()) {
3141 : if (val) *val = d;
3142 : return SWIG_AddCast(SWIG_OK);
3143 : } else {
3144 : PyErr_Clear();
3145 : }
3146 : if (!dispatch) {
3147 : long v = PyLong_AsLong(obj);
3148 : if (!PyErr_Occurred()) {
3149 : if (val) *val = v;
3150 : return SWIG_AddCast(SWIG_AddCast(SWIG_OK));
3151 : } else {
3152 : PyErr_Clear();
3153 : }
3154 : }
3155 : }
3156 : #endif
3157 : return res;
3158 : }
3159 :
3160 :
3161 : #include <float.h>
3162 :
3163 :
3164 : #include <math.h>
3165 :
3166 :
3167 : SWIGINTERNINLINE int
3168 : SWIG_CanCastAsInteger(double *d, double min, double max) {
3169 : double x = *d;
3170 : if ((min <= x && x <= max)) {
3171 : double fx = floor(x);
3172 : double cx = ceil(x);
3173 : double rd = ((x - fx) < 0.5) ? fx : cx; /* simple rint */
3174 : if ((errno == EDOM) || (errno == ERANGE)) {
3175 : errno = 0;
3176 : } else {
3177 : double summ, reps, diff;
3178 : if (rd < x) {
3179 : diff = x - rd;
3180 : } else if (rd > x) {
3181 : diff = rd - x;
3182 : } else {
3183 : return 1;
3184 : }
3185 : summ = rd + x;
3186 : reps = diff/summ;
3187 : if (reps < 8*DBL_EPSILON) {
3188 : *d = rd;
3189 : return 1;
3190 : }
3191 : }
3192 : }
3193 : return 0;
3194 : }
3195 :
3196 :
3197 : SWIGINTERN int
3198 615 : SWIG_AsVal_long (PyObject *obj, long* val)
3199 : {
3200 : #if PY_VERSION_HEX < 0x03000000
3201 615 : if (PyInt_Check(obj)) {
3202 615 : if (val) *val = PyInt_AsLong(obj);
3203 : return SWIG_OK;
3204 : } else
3205 : #endif
3206 0 : if (PyLong_Check(obj)) {
3207 0 : long v = PyLong_AsLong(obj);
3208 0 : if (!PyErr_Occurred()) {
3209 0 : if (val) *val = v;
3210 : return SWIG_OK;
3211 : } else {
3212 0 : PyErr_Clear();
3213 0 : return SWIG_OverflowError;
3214 : }
3215 : }
3216 : #ifdef SWIG_PYTHON_CAST_MODE
3217 : {
3218 : int dispatch = 0;
3219 : long v = PyInt_AsLong(obj);
3220 : if (!PyErr_Occurred()) {
3221 : if (val) *val = v;
3222 : return SWIG_AddCast(SWIG_OK);
3223 : } else {
3224 : PyErr_Clear();
3225 : }
3226 : if (!dispatch) {
3227 : double d;
3228 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3229 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
3230 : if (val) *val = (long)(d);
3231 : return res;
3232 : }
3233 : }
3234 : }
3235 : #endif
3236 : return SWIG_TypeError;
3237 : }
3238 :
3239 :
3240 : SWIGINTERN int
3241 : SWIG_AsVal_int (PyObject * obj, int *val)
3242 : {
3243 : long v;
3244 615 : int res = SWIG_AsVal_long (obj, &v);
3245 615 : if (SWIG_IsOK(res)) {
3246 615 : if ((v < INT_MIN || v > INT_MAX)) {
3247 : return SWIG_OverflowError;
3248 : } else {
3249 615 : if (val) *val = (int)(v);
3250 : }
3251 : }
3252 : return res;
3253 : }
3254 :
3255 :
3256 : SWIGINTERN swig_type_info*
3257 0 : SWIG_pchar_descriptor(void)
3258 : {
3259 : static int init = 0;
3260 : static swig_type_info* info = 0;
3261 0 : if (!init) {
3262 0 : info = SWIG_TypeQuery("_p_char");
3263 0 : init = 1;
3264 : }
3265 0 : return info;
3266 : }
3267 :
3268 :
3269 : SWIGINTERN int
3270 0 : SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3271 : {
3272 : #if PY_VERSION_HEX>=0x03000000
3273 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3274 : if (PyBytes_Check(obj))
3275 : #else
3276 : if (PyUnicode_Check(obj))
3277 : #endif
3278 : #else
3279 0 : if (PyString_Check(obj))
3280 : #endif
3281 : {
3282 : char *cstr; Py_ssize_t len;
3283 : #if PY_VERSION_HEX>=0x03000000
3284 : #if !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3285 : if (!alloc && cptr) {
3286 : /* We can't allow converting without allocation, since the internal
3287 : representation of string in Python 3 is UCS-2/UCS-4 but we require
3288 : a UTF-8 representation.
3289 : TODO(bhy) More detailed explanation */
3290 : return SWIG_RuntimeError;
3291 : }
3292 : obj = PyUnicode_AsUTF8String(obj);
3293 : if(alloc) *alloc = SWIG_NEWOBJ;
3294 : #endif
3295 : PyBytes_AsStringAndSize(obj, &cstr, &len);
3296 : #else
3297 0 : PyString_AsStringAndSize(obj, &cstr, &len);
3298 : #endif
3299 0 : if (cptr) {
3300 0 : if (alloc) {
3301 : /*
3302 : In python the user should not be able to modify the inner
3303 : string representation. To warranty that, if you define
3304 : SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3305 : buffer is always returned.
3306 :
3307 : The default behavior is just to return the pointer value,
3308 : so, be careful.
3309 : */
3310 : #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3311 : if (*alloc != SWIG_OLDOBJ)
3312 : #else
3313 0 : if (*alloc == SWIG_NEWOBJ)
3314 : #endif
3315 : {
3316 0 : *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3317 0 : *alloc = SWIG_NEWOBJ;
3318 : } else {
3319 0 : *cptr = cstr;
3320 0 : *alloc = SWIG_OLDOBJ;
3321 : }
3322 : } else {
3323 : #if PY_VERSION_HEX>=0x03000000
3324 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3325 : *cptr = PyBytes_AsString(obj);
3326 : #else
3327 : assert(0); /* Should never reach here with Unicode strings in Python 3 */
3328 : #endif
3329 : #else
3330 0 : *cptr = SWIG_Python_str_AsChar(obj);
3331 : #endif
3332 : }
3333 : }
3334 0 : if (psize) *psize = len + 1;
3335 : #if PY_VERSION_HEX>=0x03000000 && !defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3336 : Py_XDECREF(obj);
3337 : #endif
3338 : return SWIG_OK;
3339 : } else {
3340 : #if defined(SWIG_PYTHON_2_UNICODE)
3341 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3342 : #error "Cannot use both SWIG_PYTHON_2_UNICODE and SWIG_PYTHON_STRICT_BYTE_CHAR at once"
3343 : #endif
3344 : #if PY_VERSION_HEX<0x03000000
3345 : if (PyUnicode_Check(obj)) {
3346 : char *cstr; Py_ssize_t len;
3347 : if (!alloc && cptr) {
3348 : return SWIG_RuntimeError;
3349 : }
3350 : obj = PyUnicode_AsUTF8String(obj);
3351 : if (PyString_AsStringAndSize(obj, &cstr, &len) != -1) {
3352 : if (cptr) {
3353 : if (alloc) *alloc = SWIG_NEWOBJ;
3354 : *cptr = (char *)memcpy((char *)malloc((len + 1)*sizeof(char)), cstr, sizeof(char)*(len + 1));
3355 : }
3356 : if (psize) *psize = len + 1;
3357 :
3358 : Py_XDECREF(obj);
3359 : return SWIG_OK;
3360 : } else {
3361 : Py_XDECREF(obj);
3362 : }
3363 : }
3364 : #endif
3365 : #endif
3366 :
3367 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3368 0 : if (pchar_descriptor) {
3369 0 : void* vptr = 0;
3370 0 : if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3371 0 : if (cptr) *cptr = (char *) vptr;
3372 0 : if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3373 0 : if (alloc) *alloc = SWIG_OLDOBJ;
3374 0 : return SWIG_OK;
3375 : }
3376 : }
3377 : }
3378 : return SWIG_TypeError;
3379 : }
3380 :
3381 :
3382 :
3383 :
3384 :
3385 : #ifdef HAVE_CONFIG_H
3386 : #include "config.h"
3387 : #endif
3388 :
3389 : #include <gpgme.h>
3390 :
3391 :
3392 : SWIGINTERNINLINE PyObject *
3393 1689 : SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3394 : {
3395 1689 : if (carray) {
3396 1356 : if (size > INT_MAX) {
3397 0 : swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3398 : return pchar_descriptor ?
3399 0 : SWIG_InternalNewPointerObj((char *)(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3400 : } else {
3401 : #if PY_VERSION_HEX >= 0x03000000
3402 : #if defined(SWIG_PYTHON_STRICT_BYTE_CHAR)
3403 : return PyBytes_FromStringAndSize(carray, (Py_ssize_t)(size));
3404 : #else
3405 : #if PY_VERSION_HEX >= 0x03010000
3406 : return PyUnicode_DecodeUTF8(carray, (Py_ssize_t)(size), "surrogateescape");
3407 : #else
3408 : return PyUnicode_FromStringAndSize(carray, (Py_ssize_t)(size));
3409 : #endif
3410 : #endif
3411 : #else
3412 1410 : return PyString_FromStringAndSize(carray, (Py_ssize_t)(size));
3413 : #endif
3414 : }
3415 : } else {
3416 333 : return SWIG_Py_Void();
3417 : }
3418 : }
3419 :
3420 :
3421 : SWIGINTERNINLINE PyObject *
3422 1257 : SWIG_FromCharPtr(const char *cptr)
3423 : {
3424 1689 : return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3425 : }
3426 :
3427 :
3428 : SWIGINTERN int
3429 181 : SWIG_AsVal_unsigned_SS_long (PyObject *obj, unsigned long *val)
3430 : {
3431 : #if PY_VERSION_HEX < 0x03000000
3432 181 : if (PyInt_Check(obj)) {
3433 181 : long v = PyInt_AsLong(obj);
3434 181 : if (v >= 0) {
3435 181 : if (val) *val = v;
3436 : return SWIG_OK;
3437 : } else {
3438 : return SWIG_OverflowError;
3439 : }
3440 : } else
3441 : #endif
3442 0 : if (PyLong_Check(obj)) {
3443 0 : unsigned long v = PyLong_AsUnsignedLong(obj);
3444 0 : if (!PyErr_Occurred()) {
3445 0 : if (val) *val = v;
3446 : return SWIG_OK;
3447 : } else {
3448 0 : PyErr_Clear();
3449 0 : return SWIG_OverflowError;
3450 : }
3451 : }
3452 : #ifdef SWIG_PYTHON_CAST_MODE
3453 : {
3454 : int dispatch = 0;
3455 : unsigned long v = PyLong_AsUnsignedLong(obj);
3456 : if (!PyErr_Occurred()) {
3457 : if (val) *val = v;
3458 : return SWIG_AddCast(SWIG_OK);
3459 : } else {
3460 : PyErr_Clear();
3461 : }
3462 : if (!dispatch) {
3463 : double d;
3464 : int res = SWIG_AddCast(SWIG_AsVal_double (obj,&d));
3465 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
3466 : if (val) *val = (unsigned long)(d);
3467 : return res;
3468 : }
3469 : }
3470 : }
3471 : #endif
3472 : return SWIG_TypeError;
3473 : }
3474 :
3475 :
3476 : SWIGINTERN int
3477 : SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3478 : {
3479 : unsigned long v;
3480 77 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3481 77 : if (SWIG_IsOK(res)) {
3482 77 : if ((v > UINT_MAX)) {
3483 : return SWIG_OverflowError;
3484 : } else {
3485 77 : if (val) *val = (unsigned int)(v);
3486 : }
3487 : }
3488 : return res;
3489 : }
3490 :
3491 :
3492 : SWIGINTERNINLINE PyObject*
3493 : SWIG_From_unsigned_SS_int (unsigned int value)
3494 : {
3495 2042 : return PyInt_FromSize_t((size_t) value);
3496 : }
3497 :
3498 :
3499 : SWIGINTERNINLINE PyObject*
3500 : SWIG_From_int (int value)
3501 : {
3502 9787 : return PyInt_FromLong((long) value);
3503 : }
3504 :
3505 :
3506 : SWIGINTERNINLINE PyObject *
3507 : SWIG_From_char (char c)
3508 : {
3509 54 : return SWIG_FromCharPtrAndSize(&c,1);
3510 : }
3511 :
3512 :
3513 : #if defined(LLONG_MAX) && !defined(SWIG_LONG_LONG_AVAILABLE)
3514 : # define SWIG_LONG_LONG_AVAILABLE
3515 : #endif
3516 :
3517 :
3518 : #ifdef SWIG_LONG_LONG_AVAILABLE
3519 : SWIGINTERN int
3520 : SWIG_AsVal_unsigned_SS_long_SS_long (PyObject *obj, unsigned long long *val)
3521 : {
3522 : int res = SWIG_TypeError;
3523 : if (PyLong_Check(obj)) {
3524 : unsigned long long v = PyLong_AsUnsignedLongLong(obj);
3525 : if (!PyErr_Occurred()) {
3526 : if (val) *val = v;
3527 : return SWIG_OK;
3528 : } else {
3529 : PyErr_Clear();
3530 : res = SWIG_OverflowError;
3531 : }
3532 : } else {
3533 : unsigned long v;
3534 : res = SWIG_AsVal_unsigned_SS_long (obj,&v);
3535 : if (SWIG_IsOK(res)) {
3536 : if (val) *val = v;
3537 : return res;
3538 : }
3539 : }
3540 : #ifdef SWIG_PYTHON_CAST_MODE
3541 : {
3542 : const double mant_max = 1LL << DBL_MANT_DIG;
3543 : double d;
3544 : res = SWIG_AsVal_double (obj,&d);
3545 : if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, mant_max)) {
3546 : if (val) *val = (unsigned long long)(d);
3547 : return SWIG_AddCast(res);
3548 : }
3549 : res = SWIG_TypeError;
3550 : }
3551 : #endif
3552 : return res;
3553 : }
3554 : #endif
3555 :
3556 :
3557 : SWIGINTERNINLINE int
3558 : SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3559 : {
3560 26 : int res = SWIG_TypeError;
3561 : #ifdef SWIG_LONG_LONG_AVAILABLE
3562 : if (sizeof(size_t) <= sizeof(unsigned long)) {
3563 : #endif
3564 : unsigned long v;
3565 26 : res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3566 26 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3567 : #ifdef SWIG_LONG_LONG_AVAILABLE
3568 : } else if (sizeof(size_t) <= sizeof(unsigned long long)) {
3569 : unsigned long long v;
3570 : res = SWIG_AsVal_unsigned_SS_long_SS_long (obj, val ? &v : 0);
3571 : if (SWIG_IsOK(res) && val) *val = (size_t)(v);
3572 : }
3573 : #endif
3574 : return res;
3575 : }
3576 :
3577 :
3578 : SWIGINTERN int
3579 : SWIG_AsVal_unsigned_SS_short (PyObject * obj, unsigned short *val)
3580 : {
3581 : unsigned long v;
3582 0 : int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3583 0 : if (SWIG_IsOK(res)) {
3584 0 : if ((v > USHRT_MAX)) {
3585 : return SWIG_OverflowError;
3586 : } else {
3587 0 : if (val) *val = (unsigned short)(v);
3588 : }
3589 : }
3590 : return res;
3591 : }
3592 :
3593 :
3594 : #define SWIG_From_long PyInt_FromLong
3595 :
3596 :
3597 : SWIGINTERNINLINE PyObject*
3598 30 : SWIG_From_unsigned_SS_long (unsigned long value)
3599 : {
3600 30 : return (value > LONG_MAX) ?
3601 30 : PyLong_FromUnsignedLong(value) : PyInt_FromLong((long)(value));
3602 : }
3603 :
3604 :
3605 : SWIGINTERNINLINE PyObject *
3606 : SWIG_From_unsigned_SS_short (unsigned short value)
3607 : {
3608 0 : return SWIG_From_unsigned_SS_long (value);
3609 : }
3610 :
3611 :
3612 : SWIGINTERN int
3613 0 : SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3614 : {
3615 0 : char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3616 0 : int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3617 0 : if (SWIG_IsOK(res)) {
3618 : /* special case of single char conversion when we don't need space for NUL */
3619 0 : if (size == 1 && csize == 2 && cptr && !cptr[1]) --csize;
3620 0 : if (csize <= size) {
3621 0 : if (val) {
3622 0 : if (csize) memcpy(val, cptr, csize*sizeof(char));
3623 0 : if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3624 : }
3625 0 : if (alloc == SWIG_NEWOBJ) {
3626 0 : free((char*)cptr);
3627 0 : res = SWIG_DelNewMask(res);
3628 : }
3629 : return res;
3630 : }
3631 0 : if (alloc == SWIG_NEWOBJ) free((char*)cptr);
3632 : }
3633 : return SWIG_TypeError;
3634 : }
3635 :
3636 :
3637 : size_t
3638 0 : SWIG_strnlen(const char* s, size_t maxlen)
3639 : {
3640 : const char *p;
3641 0 : for (p = s; maxlen-- && *p; p++)
3642 : ;
3643 0 : return p - s;
3644 : }
3645 :
3646 : typedef union {
3647 : unsigned int count;
3648 : unsigned int uint32;
3649 : int int32;
3650 : char *string;
3651 : } gpgme_conf_arg_value;
3652 :
3653 :
3654 : static gpgme_ctx_t *new_gpgme_ctx_t_p() {
3655 48 : return (gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t));
3656 : }
3657 :
3658 : static gpgme_ctx_t *copy_gpgme_ctx_t_p(gpgme_ctx_t value) {
3659 0 : return (gpgme_ctx_t *)memcpy((gpgme_ctx_t *)malloc(sizeof(gpgme_ctx_t)),&value,sizeof(gpgme_ctx_t));
3660 : }
3661 :
3662 : static void delete_gpgme_ctx_t_p(gpgme_ctx_t *obj) {
3663 48 : if (obj) free((char*)obj);
3664 : }
3665 :
3666 : static void gpgme_ctx_t_p_assign(gpgme_ctx_t *obj, gpgme_ctx_t value) {
3667 0 : *obj = value;
3668 : }
3669 :
3670 : static gpgme_ctx_t gpgme_ctx_t_p_value(gpgme_ctx_t *obj) {
3671 : return *obj;
3672 : }
3673 :
3674 :
3675 : static gpgme_data_t *new_gpgme_data_t_p() {
3676 108 : return (gpgme_data_t *)malloc(sizeof(gpgme_data_t));
3677 : }
3678 :
3679 : static gpgme_data_t *copy_gpgme_data_t_p(gpgme_data_t value) {
3680 0 : return (gpgme_data_t *)memcpy((gpgme_data_t *)malloc(sizeof(gpgme_data_t)),&value,sizeof(gpgme_data_t));
3681 : }
3682 :
3683 : static void delete_gpgme_data_t_p(gpgme_data_t *obj) {
3684 108 : if (obj) free((char*)obj);
3685 : }
3686 :
3687 : static void gpgme_data_t_p_assign(gpgme_data_t *obj, gpgme_data_t value) {
3688 0 : *obj = value;
3689 : }
3690 :
3691 : static gpgme_data_t gpgme_data_t_p_value(gpgme_data_t *obj) {
3692 : return *obj;
3693 : }
3694 :
3695 :
3696 : static gpgme_key_t *new_gpgme_key_t_p() {
3697 180 : return (gpgme_key_t *)malloc(sizeof(gpgme_key_t));
3698 : }
3699 :
3700 : static gpgme_key_t *copy_gpgme_key_t_p(gpgme_key_t value) {
3701 0 : return (gpgme_key_t *)memcpy((gpgme_key_t *)malloc(sizeof(gpgme_key_t)),&value,sizeof(gpgme_key_t));
3702 : }
3703 :
3704 : static void delete_gpgme_key_t_p(gpgme_key_t *obj) {
3705 178 : if (obj) free((char*)obj);
3706 : }
3707 :
3708 : static void gpgme_key_t_p_assign(gpgme_key_t *obj, gpgme_key_t value) {
3709 0 : *obj = value;
3710 : }
3711 :
3712 : static gpgme_key_t gpgme_key_t_p_value(gpgme_key_t *obj) {
3713 : return *obj;
3714 : }
3715 :
3716 :
3717 : static gpgme_error_t *new_gpgme_error_t_p() {
3718 16 : return (gpgme_error_t *)malloc(sizeof(gpgme_error_t));
3719 : }
3720 :
3721 : static gpgme_error_t *copy_gpgme_error_t_p(gpgme_error_t value) {
3722 0 : return (gpgme_error_t *)memcpy((gpgme_error_t *)malloc(sizeof(gpgme_error_t)),&value,sizeof(gpgme_error_t));
3723 : }
3724 :
3725 : static void delete_gpgme_error_t_p(gpgme_error_t *obj) {
3726 16 : if (obj) free((char*)obj);
3727 : }
3728 :
3729 : static void gpgme_error_t_p_assign(gpgme_error_t *obj, gpgme_error_t value) {
3730 0 : *obj = value;
3731 : }
3732 :
3733 : static gpgme_error_t gpgme_error_t_p_value(gpgme_error_t *obj) {
3734 : return *obj;
3735 : }
3736 :
3737 :
3738 : static gpgme_trust_item_t *new_gpgme_trust_item_t_p() {
3739 2 : return (gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t));
3740 : }
3741 :
3742 : static gpgme_trust_item_t *copy_gpgme_trust_item_t_p(gpgme_trust_item_t value) {
3743 0 : return (gpgme_trust_item_t *)memcpy((gpgme_trust_item_t *)malloc(sizeof(gpgme_trust_item_t)),&value,sizeof(gpgme_trust_item_t));
3744 : }
3745 :
3746 : static void delete_gpgme_trust_item_t_p(gpgme_trust_item_t *obj) {
3747 2 : if (obj) free((char*)obj);
3748 : }
3749 :
3750 : static void gpgme_trust_item_t_p_assign(gpgme_trust_item_t *obj, gpgme_trust_item_t value) {
3751 0 : *obj = value;
3752 : }
3753 :
3754 : static gpgme_trust_item_t gpgme_trust_item_t_p_value(gpgme_trust_item_t *obj) {
3755 : return *obj;
3756 : }
3757 :
3758 :
3759 : static gpgme_engine_info_t *new_gpgme_engine_info_t_p() {
3760 0 : return (gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t));
3761 : }
3762 :
3763 : static gpgme_engine_info_t *copy_gpgme_engine_info_t_p(gpgme_engine_info_t value) {
3764 0 : return (gpgme_engine_info_t *)memcpy((gpgme_engine_info_t *)malloc(sizeof(gpgme_engine_info_t)),&value,sizeof(gpgme_engine_info_t));
3765 : }
3766 :
3767 : static void delete_gpgme_engine_info_t_p(gpgme_engine_info_t *obj) {
3768 0 : if (obj) free((char*)obj);
3769 : }
3770 :
3771 : static void gpgme_engine_info_t_p_assign(gpgme_engine_info_t *obj, gpgme_engine_info_t value) {
3772 0 : *obj = value;
3773 : }
3774 :
3775 : static gpgme_engine_info_t gpgme_engine_info_t_p_value(gpgme_engine_info_t *obj) {
3776 : return *obj;
3777 : }
3778 :
3779 :
3780 : #include <stdio.h>
3781 :
3782 :
3783 : #include "helpers.h"
3784 : #include "private.h"
3785 :
3786 : /* SWIG runtime support for helpers.c */
3787 : PyObject *
3788 41 : _gpg_wrap_gpgme_data_t(gpgme_data_t data)
3789 : {
3790 : /*
3791 : * If SWIG is invoked without -builtin, the macro SWIG_NewPointerObj
3792 : * expects a variable named "self".
3793 : *
3794 : * XXX: It is not quite clear why passing NULL as self is okay, but
3795 : * it works with -builtin, and it seems to work just fine without
3796 : * it too.
3797 : */
3798 41 : PyObject* self = NULL;
3799 : (void) self;
3800 41 : return SWIG_NewPointerObj(data, SWIGTYPE_p_gpgme_data, 0);
3801 : }
3802 :
3803 : gpgme_ctx_t
3804 225 : _gpg_unwrap_gpgme_ctx_t(PyObject *wrapped)
3805 : {
3806 : gpgme_ctx_t result;
3807 225 : if (SWIG_ConvertPtr(wrapped,
3808 : (void **) &result,
3809 : SWIGTYPE_p_gpgme_context,
3810 : SWIG_POINTER_EXCEPTION) == -1)
3811 : return NULL;
3812 225 : return result;
3813 : }
3814 :
3815 : #ifdef __cplusplus
3816 : extern "C" {
3817 : #endif
3818 17 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3819 17 : PyObject *resultobj = 0;
3820 17 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
3821 17 : char *arg2 = (char *) "" ;
3822 17 : int arg3 = (int) 0 ;
3823 17 : void *argp1 = 0 ;
3824 17 : int res1 = 0 ;
3825 17 : PyObject *encodedInput2 = NULL ;
3826 : int val3 ;
3827 17 : int ecode3 = 0 ;
3828 17 : PyObject * obj0 = 0 ;
3829 17 : PyObject * obj1 = 0 ;
3830 17 : PyObject * obj2 = 0 ;
3831 : gpgme_error_t result;
3832 :
3833 17 : if (!PyArg_ParseTuple(args,(char *)"O|OO:gpgme_op_keylist_start",&obj0,&obj1,&obj2)) SWIG_fail;
3834 17 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
3835 17 : if (!SWIG_IsOK(res1)) {
3836 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
3837 : }
3838 17 : arg1 = (gpgme_ctx_t)(argp1);
3839 17 : if (obj1) {
3840 : {
3841 16 : if (obj1 == Py_None)
3842 : arg2 = NULL;
3843 12 : else if (PyUnicode_Check(obj1))
3844 : {
3845 1 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
3846 1 : if (encodedInput2 == NULL)
3847 : return NULL;
3848 1 : arg2 = PyBytes_AsString(encodedInput2);
3849 : }
3850 11 : else if (PyBytes_Check(obj1))
3851 11 : arg2 = PyBytes_AsString(obj1);
3852 : else {
3853 0 : PyErr_Format(PyExc_TypeError,
3854 : "arg %d: expected str, bytes, or None, got %s",
3855 : 2, obj1->ob_type->tp_name);
3856 0 : return NULL;
3857 : }
3858 : }
3859 : }
3860 17 : if (obj2) {
3861 30 : ecode3 = SWIG_AsVal_int(obj2, &val3);
3862 15 : if (!SWIG_IsOK(ecode3)) {
3863 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_start" "', argument " "3"" of type '" "int""'");
3864 : }
3865 : arg3 = (int)(val3);
3866 : }
3867 : {
3868 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3869 17 : result = gpgme_op_keylist_start(arg1,(char const *)arg2,arg3);
3870 17 : SWIG_PYTHON_THREAD_END_ALLOW;
3871 : }
3872 : {
3873 17 : resultobj = PyLong_FromLong(result);
3874 : }
3875 : {
3876 17 : Py_XDECREF(encodedInput2);
3877 : }
3878 : return resultobj;
3879 : fail:
3880 : {
3881 0 : Py_XDECREF(encodedInput2);
3882 : }
3883 : return NULL;
3884 : }
3885 :
3886 :
3887 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3888 0 : PyObject *resultobj = 0;
3889 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
3890 0 : char *arg2 = (char *) 0 ;
3891 0 : void *argp1 = 0 ;
3892 0 : int res1 = 0 ;
3893 : int res2 ;
3894 0 : char *buf2 = 0 ;
3895 0 : int alloc2 = 0 ;
3896 0 : PyObject * obj0 = 0 ;
3897 0 : PyObject * obj1 = 0 ;
3898 :
3899 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_name_set",&obj0,&obj1)) SWIG_fail;
3900 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
3901 0 : if (!SWIG_IsOK(res1)) {
3902 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
3903 : }
3904 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
3905 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3906 0 : if (!SWIG_IsOK(res2)) {
3907 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_name_set" "', argument " "2"" of type '" "char *""'");
3908 : }
3909 0 : arg2 = (char *)(buf2);
3910 : {
3911 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3912 0 : if (arg1->name) free((char*)arg1->name);
3913 0 : if (arg2) {
3914 0 : size_t size = strlen((const char *)(arg2)) + 1;
3915 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3916 : } else {
3917 0 : arg1->name = 0;
3918 : }
3919 0 : SWIG_PYTHON_THREAD_END_ALLOW;
3920 : }
3921 0 : resultobj = SWIG_Py_Void();
3922 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3923 : return resultobj;
3924 : fail:
3925 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3926 : return NULL;
3927 : }
3928 :
3929 :
3930 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3931 15 : PyObject *resultobj = 0;
3932 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
3933 15 : void *argp1 = 0 ;
3934 15 : int res1 = 0 ;
3935 15 : PyObject * obj0 = 0 ;
3936 15 : char *result = 0 ;
3937 :
3938 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_name_get",&obj0)) SWIG_fail;
3939 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
3940 15 : if (!SWIG_IsOK(res1)) {
3941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_name_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
3942 : }
3943 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
3944 : {
3945 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3946 15 : result = (char *) ((arg1)->name);
3947 15 : SWIG_PYTHON_THREAD_END_ALLOW;
3948 : }
3949 15 : resultobj = SWIG_FromCharPtr((const char *)result);
3950 15 : return resultobj;
3951 : fail:
3952 : return NULL;
3953 : }
3954 :
3955 :
3956 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
3957 0 : PyObject *resultobj = 0;
3958 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
3959 0 : char *arg2 = (char *) 0 ;
3960 0 : void *argp1 = 0 ;
3961 0 : int res1 = 0 ;
3962 : int res2 ;
3963 0 : char *buf2 = 0 ;
3964 0 : int alloc2 = 0 ;
3965 0 : PyObject * obj0 = 0 ;
3966 0 : PyObject * obj1 = 0 ;
3967 :
3968 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_value_set",&obj0,&obj1)) SWIG_fail;
3969 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
3970 0 : if (!SWIG_IsOK(res1)) {
3971 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
3972 : }
3973 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
3974 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
3975 0 : if (!SWIG_IsOK(res2)) {
3976 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_sig_notation_value_set" "', argument " "2"" of type '" "char *""'");
3977 : }
3978 0 : arg2 = (char *)(buf2);
3979 : {
3980 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
3981 0 : if (arg1->value) free((char*)arg1->value);
3982 0 : if (arg2) {
3983 0 : size_t size = strlen((const char *)(arg2)) + 1;
3984 0 : arg1->value = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
3985 : } else {
3986 0 : arg1->value = 0;
3987 : }
3988 0 : SWIG_PYTHON_THREAD_END_ALLOW;
3989 : }
3990 0 : resultobj = SWIG_Py_Void();
3991 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3992 : return resultobj;
3993 : fail:
3994 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3995 : return NULL;
3996 : }
3997 :
3998 :
3999 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4000 15 : PyObject *resultobj = 0;
4001 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4002 15 : void *argp1 = 0 ;
4003 15 : int res1 = 0 ;
4004 15 : PyObject * obj0 = 0 ;
4005 15 : char *result = 0 ;
4006 :
4007 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_value_get",&obj0)) SWIG_fail;
4008 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4009 15 : if (!SWIG_IsOK(res1)) {
4010 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_value_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4011 : }
4012 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4013 : {
4014 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4015 15 : result = (char *) ((arg1)->value);
4016 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4017 : }
4018 15 : resultobj = SWIG_FromCharPtr((const char *)result);
4019 15 : return resultobj;
4020 : fail:
4021 : return NULL;
4022 : }
4023 :
4024 :
4025 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4026 0 : PyObject *resultobj = 0;
4027 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4028 : gpgme_sig_notation_flags_t arg2 ;
4029 0 : void *argp1 = 0 ;
4030 0 : int res1 = 0 ;
4031 : unsigned int val2 ;
4032 0 : int ecode2 = 0 ;
4033 0 : PyObject * obj0 = 0 ;
4034 0 : PyObject * obj1 = 0 ;
4035 :
4036 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_flags_set",&obj0,&obj1)) SWIG_fail;
4037 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4038 0 : if (!SWIG_IsOK(res1)) {
4039 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4040 : }
4041 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4042 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4043 0 : if (!SWIG_IsOK(ecode2)) {
4044 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_flags_set" "', argument " "2"" of type '" "gpgme_sig_notation_flags_t""'");
4045 : }
4046 0 : arg2 = (gpgme_sig_notation_flags_t)(val2);
4047 : {
4048 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4049 0 : if (arg1) (arg1)->flags = arg2;
4050 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4051 : }
4052 0 : resultobj = SWIG_Py_Void();
4053 0 : return resultobj;
4054 : fail:
4055 : return NULL;
4056 : }
4057 :
4058 :
4059 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4060 15 : PyObject *resultobj = 0;
4061 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4062 15 : void *argp1 = 0 ;
4063 15 : int res1 = 0 ;
4064 15 : PyObject * obj0 = 0 ;
4065 : gpgme_sig_notation_flags_t result;
4066 :
4067 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_flags_get",&obj0)) SWIG_fail;
4068 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4069 15 : if (!SWIG_IsOK(res1)) {
4070 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_flags_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4071 : }
4072 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4073 : {
4074 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4075 15 : result = (gpgme_sig_notation_flags_t) ((arg1)->flags);
4076 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4077 : }
4078 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4079 15 : return resultobj;
4080 : fail:
4081 : return NULL;
4082 : }
4083 :
4084 :
4085 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4086 0 : PyObject *resultobj = 0;
4087 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4088 : unsigned int arg2 ;
4089 0 : void *argp1 = 0 ;
4090 0 : int res1 = 0 ;
4091 : unsigned int val2 ;
4092 0 : int ecode2 = 0 ;
4093 0 : PyObject * obj0 = 0 ;
4094 0 : PyObject * obj1 = 0 ;
4095 :
4096 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_human_readable_set",&obj0,&obj1)) SWIG_fail;
4097 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4098 0 : if (!SWIG_IsOK(res1)) {
4099 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4100 : }
4101 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4102 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4103 0 : if (!SWIG_IsOK(ecode2)) {
4104 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_human_readable_set" "', argument " "2"" of type '" "unsigned int""'");
4105 : }
4106 0 : arg2 = (unsigned int)(val2);
4107 : {
4108 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4109 0 : if (arg1) (arg1)->human_readable = arg2;
4110 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4111 : }
4112 0 : resultobj = SWIG_Py_Void();
4113 0 : return resultobj;
4114 : fail:
4115 : return NULL;
4116 : }
4117 :
4118 :
4119 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_human_readable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4120 15 : PyObject *resultobj = 0;
4121 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4122 15 : void *argp1 = 0 ;
4123 15 : int res1 = 0 ;
4124 15 : PyObject * obj0 = 0 ;
4125 : unsigned int result;
4126 :
4127 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_human_readable_get",&obj0)) SWIG_fail;
4128 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4129 15 : if (!SWIG_IsOK(res1)) {
4130 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_human_readable_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4131 : }
4132 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4133 : {
4134 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4135 15 : result = (unsigned int) ((arg1)->human_readable);
4136 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4137 : }
4138 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4139 15 : return resultobj;
4140 : fail:
4141 : return NULL;
4142 : }
4143 :
4144 :
4145 0 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4146 0 : PyObject *resultobj = 0;
4147 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4148 : unsigned int arg2 ;
4149 0 : void *argp1 = 0 ;
4150 0 : int res1 = 0 ;
4151 : unsigned int val2 ;
4152 0 : int ecode2 = 0 ;
4153 0 : PyObject * obj0 = 0 ;
4154 0 : PyObject * obj1 = 0 ;
4155 :
4156 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_sig_notation_critical_set",&obj0,&obj1)) SWIG_fail;
4157 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4158 0 : if (!SWIG_IsOK(res1)) {
4159 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4160 : }
4161 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4162 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
4163 0 : if (!SWIG_IsOK(ecode2)) {
4164 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_sig_notation_critical_set" "', argument " "2"" of type '" "unsigned int""'");
4165 : }
4166 0 : arg2 = (unsigned int)(val2);
4167 : {
4168 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4169 0 : if (arg1) (arg1)->critical = arg2;
4170 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4171 : }
4172 0 : resultobj = SWIG_Py_Void();
4173 0 : return resultobj;
4174 : fail:
4175 : return NULL;
4176 : }
4177 :
4178 :
4179 15 : SWIGINTERN PyObject *_wrap__gpgme_sig_notation_critical_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4180 15 : PyObject *resultobj = 0;
4181 15 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4182 15 : void *argp1 = 0 ;
4183 15 : int res1 = 0 ;
4184 15 : PyObject * obj0 = 0 ;
4185 : unsigned int result;
4186 :
4187 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_sig_notation_critical_get",&obj0)) SWIG_fail;
4188 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, 0 | 0 );
4189 15 : if (!SWIG_IsOK(res1)) {
4190 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_sig_notation_critical_get" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4191 : }
4192 15 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4193 : {
4194 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4195 15 : result = (unsigned int) ((arg1)->critical);
4196 15 : SWIG_PYTHON_THREAD_END_ALLOW;
4197 : }
4198 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
4199 15 : return resultobj;
4200 : fail:
4201 : return NULL;
4202 : }
4203 :
4204 :
4205 0 : SWIGINTERN PyObject *_wrap_new__gpgme_sig_notation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4206 0 : PyObject *resultobj = 0;
4207 0 : struct _gpgme_sig_notation *result = 0 ;
4208 :
4209 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_sig_notation")) SWIG_fail;
4210 : {
4211 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4212 0 : result = (struct _gpgme_sig_notation *)calloc(1, sizeof(struct _gpgme_sig_notation));
4213 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4214 : }
4215 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_NEW | 0 );
4216 0 : return resultobj;
4217 : fail:
4218 : return NULL;
4219 : }
4220 :
4221 :
4222 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_sig_notation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4223 0 : PyObject *resultobj = 0;
4224 0 : struct _gpgme_sig_notation *arg1 = (struct _gpgme_sig_notation *) 0 ;
4225 0 : void *argp1 = 0 ;
4226 0 : int res1 = 0 ;
4227 0 : PyObject * obj0 = 0 ;
4228 :
4229 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_sig_notation",&obj0)) SWIG_fail;
4230 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
4231 0 : if (!SWIG_IsOK(res1)) {
4232 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_sig_notation" "', argument " "1"" of type '" "struct _gpgme_sig_notation *""'");
4233 : }
4234 0 : arg1 = (struct _gpgme_sig_notation *)(argp1);
4235 : {
4236 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4237 0 : free((char *) arg1);
4238 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4239 : }
4240 0 : resultobj = SWIG_Py_Void();
4241 0 : return resultobj;
4242 : fail:
4243 : return NULL;
4244 : }
4245 :
4246 :
4247 27 : SWIGINTERN PyObject *_gpgme_sig_notation_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4248 : PyObject *obj;
4249 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
4250 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_sig_notation, SWIG_NewClientData(obj));
4251 27 : return SWIG_Py_Void();
4252 : }
4253 :
4254 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4255 0 : PyObject *resultobj = 0;
4256 : gpgme_err_source_t arg1 ;
4257 : gpgme_err_code_t arg2 ;
4258 0 : PyObject * obj0 = 0 ;
4259 0 : PyObject * obj1 = 0 ;
4260 : gpgme_error_t result;
4261 :
4262 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make",&obj0,&obj1)) SWIG_fail;
4263 : {
4264 0 : if (PyLong_Check(obj0))
4265 0 : arg1 = PyLong_AsLong(obj0);
4266 :
4267 0 : else if (PyInt_Check(obj0))
4268 0 : arg1 = PyInt_AsLong(obj0);
4269 :
4270 : else
4271 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4272 : }
4273 : {
4274 0 : if (PyLong_Check(obj1))
4275 0 : arg2 = PyLong_AsLong(obj1);
4276 :
4277 0 : else if (PyInt_Check(obj1))
4278 0 : arg2 = PyInt_AsLong(obj1);
4279 :
4280 : else
4281 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4282 : }
4283 : {
4284 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4285 0 : result = gpgme_err_make(arg1,arg2);
4286 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4287 : }
4288 : {
4289 0 : resultobj = PyLong_FromLong(result);
4290 : }
4291 0 : return resultobj;
4292 : fail:
4293 : return NULL;
4294 : }
4295 :
4296 :
4297 0 : SWIGINTERN PyObject *_wrap_gpgme_error(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4298 0 : PyObject *resultobj = 0;
4299 : gpgme_err_code_t arg1 ;
4300 0 : PyObject * obj0 = 0 ;
4301 : gpgme_error_t result;
4302 :
4303 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error",&obj0)) SWIG_fail;
4304 : {
4305 0 : if (PyLong_Check(obj0))
4306 0 : arg1 = PyLong_AsLong(obj0);
4307 :
4308 0 : else if (PyInt_Check(obj0))
4309 0 : arg1 = PyInt_AsLong(obj0);
4310 :
4311 : else
4312 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4313 : }
4314 : {
4315 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4316 0 : result = gpgme_error(arg1);
4317 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4318 : }
4319 : {
4320 0 : resultobj = PyLong_FromLong(result);
4321 : }
4322 0 : return resultobj;
4323 : fail:
4324 : return NULL;
4325 : }
4326 :
4327 :
4328 43 : SWIGINTERN PyObject *_wrap_gpgme_err_code(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4329 43 : PyObject *resultobj = 0;
4330 : gpgme_error_t arg1 ;
4331 43 : PyObject * obj0 = 0 ;
4332 : gpgme_err_code_t result;
4333 :
4334 43 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code",&obj0)) SWIG_fail;
4335 : {
4336 43 : if (PyLong_Check(obj0))
4337 43 : arg1 = PyLong_AsLong(obj0);
4338 :
4339 0 : else if (PyInt_Check(obj0))
4340 0 : arg1 = PyInt_AsLong(obj0);
4341 :
4342 : else
4343 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4344 : }
4345 : {
4346 43 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4347 43 : result = gpgme_err_code(arg1);
4348 43 : SWIG_PYTHON_THREAD_END_ALLOW;
4349 : }
4350 : {
4351 43 : resultobj = PyLong_FromLong(result);
4352 : }
4353 43 : return resultobj;
4354 : fail:
4355 : return NULL;
4356 : }
4357 :
4358 :
4359 1 : SWIGINTERN PyObject *_wrap_gpgme_err_source(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4360 1 : PyObject *resultobj = 0;
4361 : gpgme_error_t arg1 ;
4362 1 : PyObject * obj0 = 0 ;
4363 : gpgme_err_source_t result;
4364 :
4365 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_source",&obj0)) SWIG_fail;
4366 : {
4367 1 : if (PyLong_Check(obj0))
4368 1 : arg1 = PyLong_AsLong(obj0);
4369 :
4370 0 : else if (PyInt_Check(obj0))
4371 0 : arg1 = PyInt_AsLong(obj0);
4372 :
4373 : else
4374 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4375 : }
4376 : {
4377 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4378 1 : result = gpgme_err_source(arg1);
4379 1 : SWIG_PYTHON_THREAD_END_ALLOW;
4380 : }
4381 : {
4382 1 : resultobj = PyLong_FromLong(result);
4383 : }
4384 1 : return resultobj;
4385 : fail:
4386 : return NULL;
4387 : }
4388 :
4389 :
4390 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4391 0 : PyObject *resultobj = 0;
4392 : gpgme_error_t arg1 ;
4393 0 : PyObject * obj0 = 0 ;
4394 0 : char *result = 0 ;
4395 :
4396 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strerror",&obj0)) SWIG_fail;
4397 : {
4398 0 : if (PyLong_Check(obj0))
4399 0 : arg1 = PyLong_AsLong(obj0);
4400 :
4401 0 : else if (PyInt_Check(obj0))
4402 0 : arg1 = PyInt_AsLong(obj0);
4403 :
4404 : else
4405 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4406 : }
4407 : {
4408 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4409 0 : result = (char *)gpgme_strerror(arg1);
4410 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4411 : }
4412 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4413 0 : return resultobj;
4414 : fail:
4415 : return NULL;
4416 : }
4417 :
4418 :
4419 0 : SWIGINTERN PyObject *_wrap_gpgme_strerror_r(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4420 0 : PyObject *resultobj = 0;
4421 : gpg_error_t arg1 ;
4422 0 : char *arg2 = (char *) 0 ;
4423 : size_t arg3 ;
4424 0 : PyObject * obj0 = 0 ;
4425 0 : PyObject * obj1 = 0 ;
4426 : int result;
4427 :
4428 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_strerror_r",&obj0,&obj1)) SWIG_fail;
4429 : {
4430 0 : if (PyLong_Check(obj0))
4431 0 : arg1 = PyLong_AsLong(obj0);
4432 :
4433 0 : else if (PyInt_Check(obj0))
4434 0 : arg1 = PyInt_AsLong(obj0);
4435 :
4436 : else
4437 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4438 : }
4439 : {
4440 : {
4441 : long tmp2;
4442 0 : if (PyLong_Check(obj1))
4443 0 : tmp2 = PyLong_AsLong(obj1);
4444 :
4445 0 : else if (PyInt_Check(obj1))
4446 0 : tmp2 = PyInt_AsLong(obj1);
4447 :
4448 : else
4449 : {
4450 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4451 0 : return NULL;
4452 : }
4453 :
4454 0 : if (tmp2 < 0) {
4455 0 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
4456 0 : return NULL;
4457 : }
4458 0 : arg3 = (size_t) tmp2;
4459 0 : arg2 = (char *) malloc(arg3+1);
4460 : }
4461 : }
4462 : {
4463 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4464 0 : result = (int)gpgme_strerror_r(arg1,arg2,arg3);
4465 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4466 : }
4467 0 : resultobj = SWIG_From_int((int)(result));
4468 : {
4469 0 : Py_XDECREF(resultobj); /* Blow away any previous result */
4470 0 : if (result < 0) {
4471 : /* Check for I/O error */
4472 0 : free(arg2);
4473 0 : return PyErr_SetFromErrno(PyExc_RuntimeError);
4474 : }
4475 0 : resultobj = PyBytes_FromStringAndSize(arg2,result);
4476 0 : free(arg2);
4477 : }
4478 0 : return resultobj;
4479 : fail:
4480 : return NULL;
4481 : }
4482 :
4483 :
4484 0 : SWIGINTERN PyObject *_wrap_gpgme_strsource(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4485 0 : PyObject *resultobj = 0;
4486 : gpgme_error_t arg1 ;
4487 0 : PyObject * obj0 = 0 ;
4488 0 : char *result = 0 ;
4489 :
4490 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_strsource",&obj0)) SWIG_fail;
4491 : {
4492 0 : if (PyLong_Check(obj0))
4493 0 : arg1 = PyLong_AsLong(obj0);
4494 :
4495 0 : else if (PyInt_Check(obj0))
4496 0 : arg1 = PyInt_AsLong(obj0);
4497 :
4498 : else
4499 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4500 : }
4501 : {
4502 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4503 0 : result = (char *)gpgme_strsource(arg1);
4504 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4505 : }
4506 0 : resultobj = SWIG_FromCharPtr((const char *)result);
4507 0 : return resultobj;
4508 : fail:
4509 : return NULL;
4510 : }
4511 :
4512 :
4513 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4514 0 : PyObject *resultobj = 0;
4515 : int arg1 ;
4516 : int val1 ;
4517 0 : int ecode1 = 0 ;
4518 0 : PyObject * obj0 = 0 ;
4519 : gpgme_err_code_t result;
4520 :
4521 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_from_errno",&obj0)) SWIG_fail;
4522 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4523 0 : if (!SWIG_IsOK(ecode1)) {
4524 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_code_from_errno" "', argument " "1"" of type '" "int""'");
4525 : }
4526 0 : arg1 = (int)(val1);
4527 : {
4528 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4529 0 : result = gpgme_err_code_from_errno(arg1);
4530 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4531 : }
4532 : {
4533 0 : resultobj = PyLong_FromLong(result);
4534 : }
4535 0 : return resultobj;
4536 : fail:
4537 : return NULL;
4538 : }
4539 :
4540 :
4541 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_to_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4542 0 : PyObject *resultobj = 0;
4543 : gpgme_err_code_t arg1 ;
4544 0 : PyObject * obj0 = 0 ;
4545 : int result;
4546 :
4547 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_code_to_errno",&obj0)) SWIG_fail;
4548 : {
4549 0 : if (PyLong_Check(obj0))
4550 0 : arg1 = PyLong_AsLong(obj0);
4551 :
4552 0 : else if (PyInt_Check(obj0))
4553 0 : arg1 = PyInt_AsLong(obj0);
4554 :
4555 : else
4556 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4557 : }
4558 : {
4559 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4560 0 : result = (int)gpgme_err_code_to_errno(arg1);
4561 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4562 : }
4563 0 : resultobj = SWIG_From_int((int)(result));
4564 0 : return resultobj;
4565 : fail:
4566 : return NULL;
4567 : }
4568 :
4569 :
4570 0 : SWIGINTERN PyObject *_wrap_gpgme_err_code_from_syserror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4571 0 : PyObject *resultobj = 0;
4572 : gpgme_err_code_t result;
4573 :
4574 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_err_code_from_syserror")) SWIG_fail;
4575 : {
4576 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4577 0 : result = gpgme_err_code_from_syserror();
4578 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4579 : }
4580 : {
4581 0 : resultobj = PyLong_FromLong(result);
4582 : }
4583 0 : return resultobj;
4584 : fail:
4585 : return NULL;
4586 : }
4587 :
4588 :
4589 0 : SWIGINTERN PyObject *_wrap_gpgme_err_set_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4590 0 : PyObject *resultobj = 0;
4591 : int arg1 ;
4592 : int val1 ;
4593 0 : int ecode1 = 0 ;
4594 0 : PyObject * obj0 = 0 ;
4595 :
4596 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_err_set_errno",&obj0)) SWIG_fail;
4597 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4598 0 : if (!SWIG_IsOK(ecode1)) {
4599 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_err_set_errno" "', argument " "1"" of type '" "int""'");
4600 : }
4601 0 : arg1 = (int)(val1);
4602 : {
4603 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4604 0 : gpgme_err_set_errno(arg1);
4605 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4606 : }
4607 0 : resultobj = SWIG_Py_Void();
4608 0 : return resultobj;
4609 : fail:
4610 : return NULL;
4611 : }
4612 :
4613 :
4614 0 : SWIGINTERN PyObject *_wrap_gpgme_err_make_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4615 0 : PyObject *resultobj = 0;
4616 : gpgme_err_source_t arg1 ;
4617 : int arg2 ;
4618 : int val2 ;
4619 0 : int ecode2 = 0 ;
4620 0 : PyObject * obj0 = 0 ;
4621 0 : PyObject * obj1 = 0 ;
4622 : gpgme_error_t result;
4623 :
4624 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_err_make_from_errno",&obj0,&obj1)) SWIG_fail;
4625 : {
4626 0 : if (PyLong_Check(obj0))
4627 0 : arg1 = PyLong_AsLong(obj0);
4628 :
4629 0 : else if (PyInt_Check(obj0))
4630 0 : arg1 = PyInt_AsLong(obj0);
4631 :
4632 : else
4633 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
4634 : }
4635 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4636 0 : if (!SWIG_IsOK(ecode2)) {
4637 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_err_make_from_errno" "', argument " "2"" of type '" "int""'");
4638 : }
4639 0 : arg2 = (int)(val2);
4640 : {
4641 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4642 0 : result = gpgme_err_make_from_errno(arg1,arg2);
4643 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4644 : }
4645 : {
4646 0 : resultobj = PyLong_FromLong(result);
4647 : }
4648 0 : return resultobj;
4649 : fail:
4650 : return NULL;
4651 : }
4652 :
4653 :
4654 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_errno(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4655 0 : PyObject *resultobj = 0;
4656 : int arg1 ;
4657 : int val1 ;
4658 0 : int ecode1 = 0 ;
4659 0 : PyObject * obj0 = 0 ;
4660 : gpgme_error_t result;
4661 :
4662 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_from_errno",&obj0)) SWIG_fail;
4663 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
4664 0 : if (!SWIG_IsOK(ecode1)) {
4665 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_error_from_errno" "', argument " "1"" of type '" "int""'");
4666 : }
4667 0 : arg1 = (int)(val1);
4668 : {
4669 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4670 0 : result = gpgme_error_from_errno(arg1);
4671 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4672 : }
4673 : {
4674 0 : resultobj = PyLong_FromLong(result);
4675 : }
4676 0 : return resultobj;
4677 : fail:
4678 : return NULL;
4679 : }
4680 :
4681 :
4682 0 : SWIGINTERN PyObject *_wrap_gpgme_error_from_syserror(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4683 0 : PyObject *resultobj = 0;
4684 : gpgme_error_t result;
4685 :
4686 0 : if (!PyArg_ParseTuple(args,(char *)":gpgme_error_from_syserror")) SWIG_fail;
4687 : {
4688 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4689 0 : result = gpgme_error_from_syserror();
4690 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4691 : }
4692 : {
4693 0 : resultobj = PyLong_FromLong(result);
4694 : }
4695 0 : return resultobj;
4696 : fail:
4697 : return NULL;
4698 : }
4699 :
4700 :
4701 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702 0 : PyObject *resultobj = 0;
4703 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4704 : gpgme_protocol_t arg2 ;
4705 0 : void *argp1 = 0 ;
4706 0 : int res1 = 0 ;
4707 : int val2 ;
4708 0 : int ecode2 = 0 ;
4709 0 : PyObject * obj0 = 0 ;
4710 0 : PyObject * obj1 = 0 ;
4711 :
4712 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_protocol_set",&obj0,&obj1)) SWIG_fail;
4713 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4714 0 : if (!SWIG_IsOK(res1)) {
4715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4716 : }
4717 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4718 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
4719 0 : if (!SWIG_IsOK(ecode2)) {
4720 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_engine_info_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
4721 : }
4722 0 : arg2 = (gpgme_protocol_t)(val2);
4723 : {
4724 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4725 0 : if (arg1) (arg1)->protocol = arg2;
4726 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4727 : }
4728 0 : resultobj = SWIG_Py_Void();
4729 0 : return resultobj;
4730 : fail:
4731 : return NULL;
4732 : }
4733 :
4734 :
4735 18 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_protocol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4736 18 : PyObject *resultobj = 0;
4737 18 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4738 18 : void *argp1 = 0 ;
4739 18 : int res1 = 0 ;
4740 18 : PyObject * obj0 = 0 ;
4741 : gpgme_protocol_t result;
4742 :
4743 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_protocol_get",&obj0)) SWIG_fail;
4744 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4745 18 : if (!SWIG_IsOK(res1)) {
4746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_protocol_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4747 : }
4748 18 : arg1 = (struct _gpgme_engine_info *)(argp1);
4749 : {
4750 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4751 18 : result = (gpgme_protocol_t) ((arg1)->protocol);
4752 18 : SWIG_PYTHON_THREAD_END_ALLOW;
4753 : }
4754 36 : resultobj = SWIG_From_int((int)(result));
4755 18 : return resultobj;
4756 : fail:
4757 : return NULL;
4758 : }
4759 :
4760 :
4761 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4762 0 : PyObject *resultobj = 0;
4763 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4764 0 : char *arg2 = (char *) 0 ;
4765 0 : void *argp1 = 0 ;
4766 0 : int res1 = 0 ;
4767 : int res2 ;
4768 0 : char *buf2 = 0 ;
4769 0 : int alloc2 = 0 ;
4770 0 : PyObject * obj0 = 0 ;
4771 0 : PyObject * obj1 = 0 ;
4772 :
4773 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_file_name_set",&obj0,&obj1)) SWIG_fail;
4774 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4775 0 : if (!SWIG_IsOK(res1)) {
4776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4777 : }
4778 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4779 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4780 0 : if (!SWIG_IsOK(res2)) {
4781 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_file_name_set" "', argument " "2"" of type '" "char *""'");
4782 : }
4783 0 : arg2 = (char *)(buf2);
4784 : {
4785 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4786 0 : if (arg1->file_name) free((char*)arg1->file_name);
4787 0 : if (arg2) {
4788 0 : size_t size = strlen((const char *)(arg2)) + 1;
4789 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4790 : } else {
4791 0 : arg1->file_name = 0;
4792 : }
4793 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4794 : }
4795 0 : resultobj = SWIG_Py_Void();
4796 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4797 : return resultobj;
4798 : fail:
4799 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4800 : return NULL;
4801 : }
4802 :
4803 :
4804 18 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4805 18 : PyObject *resultobj = 0;
4806 18 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4807 18 : void *argp1 = 0 ;
4808 18 : int res1 = 0 ;
4809 18 : PyObject * obj0 = 0 ;
4810 18 : char *result = 0 ;
4811 :
4812 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_file_name_get",&obj0)) SWIG_fail;
4813 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4814 18 : if (!SWIG_IsOK(res1)) {
4815 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_file_name_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4816 : }
4817 18 : arg1 = (struct _gpgme_engine_info *)(argp1);
4818 : {
4819 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4820 18 : result = (char *) ((arg1)->file_name);
4821 18 : SWIG_PYTHON_THREAD_END_ALLOW;
4822 : }
4823 18 : resultobj = SWIG_FromCharPtr((const char *)result);
4824 18 : return resultobj;
4825 : fail:
4826 : return NULL;
4827 : }
4828 :
4829 :
4830 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4831 0 : PyObject *resultobj = 0;
4832 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4833 0 : char *arg2 = (char *) 0 ;
4834 0 : void *argp1 = 0 ;
4835 0 : int res1 = 0 ;
4836 : int res2 ;
4837 0 : char *buf2 = 0 ;
4838 0 : int alloc2 = 0 ;
4839 0 : PyObject * obj0 = 0 ;
4840 0 : PyObject * obj1 = 0 ;
4841 :
4842 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_version_set",&obj0,&obj1)) SWIG_fail;
4843 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4844 0 : if (!SWIG_IsOK(res1)) {
4845 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4846 : }
4847 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4848 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
4849 0 : if (!SWIG_IsOK(res2)) {
4850 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_version_set" "', argument " "2"" of type '" "char *""'");
4851 : }
4852 0 : arg2 = (char *)(buf2);
4853 : {
4854 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4855 0 : if (arg1->version) free((char*)arg1->version);
4856 0 : if (arg2) {
4857 0 : size_t size = strlen((const char *)(arg2)) + 1;
4858 0 : arg1->version = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
4859 : } else {
4860 0 : arg1->version = 0;
4861 : }
4862 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4863 : }
4864 0 : resultobj = SWIG_Py_Void();
4865 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4866 : return resultobj;
4867 : fail:
4868 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
4869 : return NULL;
4870 : }
4871 :
4872 :
4873 18 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4874 18 : PyObject *resultobj = 0;
4875 18 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4876 18 : void *argp1 = 0 ;
4877 18 : int res1 = 0 ;
4878 18 : PyObject * obj0 = 0 ;
4879 18 : char *result = 0 ;
4880 :
4881 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_version_get",&obj0)) SWIG_fail;
4882 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4883 18 : if (!SWIG_IsOK(res1)) {
4884 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4885 : }
4886 18 : arg1 = (struct _gpgme_engine_info *)(argp1);
4887 : {
4888 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4889 18 : result = (char *) ((arg1)->version);
4890 18 : SWIG_PYTHON_THREAD_END_ALLOW;
4891 : }
4892 18 : resultobj = SWIG_FromCharPtr((const char *)result);
4893 18 : return resultobj;
4894 : fail:
4895 : return NULL;
4896 : }
4897 :
4898 :
4899 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4900 0 : PyObject *resultobj = 0;
4901 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4902 0 : char *arg2 = (char *) 0 ;
4903 0 : void *argp1 = 0 ;
4904 0 : int res1 = 0 ;
4905 0 : PyObject *encodedInput2 = NULL ;
4906 0 : PyObject * obj0 = 0 ;
4907 0 : PyObject * obj1 = 0 ;
4908 :
4909 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_req_version_set",&obj0,&obj1)) SWIG_fail;
4910 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4911 0 : if (!SWIG_IsOK(res1)) {
4912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4913 : }
4914 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
4915 : {
4916 0 : if (obj1 == Py_None)
4917 : arg2 = NULL;
4918 0 : else if (PyUnicode_Check(obj1))
4919 : {
4920 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
4921 0 : if (encodedInput2 == NULL)
4922 : return NULL;
4923 0 : arg2 = PyBytes_AsString(encodedInput2);
4924 : }
4925 0 : else if (PyBytes_Check(obj1))
4926 0 : arg2 = PyBytes_AsString(obj1);
4927 : else {
4928 0 : PyErr_Format(PyExc_TypeError,
4929 : "arg %d: expected str, bytes, or None, got %s",
4930 : 2, obj1->ob_type->tp_name);
4931 0 : return NULL;
4932 : }
4933 : }
4934 : {
4935 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4936 0 : if (arg2) {
4937 0 : size_t size = strlen((const char *)((const char *)(arg2))) + 1;
4938 0 : arg1->req_version = (char const *)(char *)memcpy((char *)malloc((size)*sizeof(char)), arg2, sizeof(char)*(size));
4939 : } else {
4940 0 : arg1->req_version = 0;
4941 : }
4942 0 : SWIG_PYTHON_THREAD_END_ALLOW;
4943 : }
4944 0 : resultobj = SWIG_Py_Void();
4945 : {
4946 0 : Py_XDECREF(encodedInput2);
4947 : }
4948 : return resultobj;
4949 : fail:
4950 : {
4951 : Py_XDECREF(encodedInput2);
4952 : }
4953 : return NULL;
4954 : }
4955 :
4956 :
4957 18 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_req_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4958 18 : PyObject *resultobj = 0;
4959 18 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4960 18 : void *argp1 = 0 ;
4961 18 : int res1 = 0 ;
4962 18 : PyObject * obj0 = 0 ;
4963 18 : char *result = 0 ;
4964 :
4965 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_req_version_get",&obj0)) SWIG_fail;
4966 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4967 18 : if (!SWIG_IsOK(res1)) {
4968 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_req_version_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4969 : }
4970 18 : arg1 = (struct _gpgme_engine_info *)(argp1);
4971 : {
4972 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
4973 18 : result = (char *) ((arg1)->req_version);
4974 18 : SWIG_PYTHON_THREAD_END_ALLOW;
4975 : }
4976 18 : resultobj = SWIG_FromCharPtr((const char *)result);
4977 18 : return resultobj;
4978 : fail:
4979 : return NULL;
4980 : }
4981 :
4982 :
4983 0 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4984 0 : PyObject *resultobj = 0;
4985 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
4986 0 : char *arg2 = (char *) 0 ;
4987 0 : void *argp1 = 0 ;
4988 0 : int res1 = 0 ;
4989 : int res2 ;
4990 0 : char *buf2 = 0 ;
4991 0 : int alloc2 = 0 ;
4992 0 : PyObject * obj0 = 0 ;
4993 0 : PyObject * obj1 = 0 ;
4994 :
4995 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_engine_info_home_dir_set",&obj0,&obj1)) SWIG_fail;
4996 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
4997 0 : if (!SWIG_IsOK(res1)) {
4998 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
4999 : }
5000 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5001 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5002 0 : if (!SWIG_IsOK(res2)) {
5003 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_engine_info_home_dir_set" "', argument " "2"" of type '" "char *""'");
5004 : }
5005 0 : arg2 = (char *)(buf2);
5006 : {
5007 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5008 0 : if (arg1->home_dir) free((char*)arg1->home_dir);
5009 0 : if (arg2) {
5010 0 : size_t size = strlen((const char *)(arg2)) + 1;
5011 0 : arg1->home_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5012 : } else {
5013 0 : arg1->home_dir = 0;
5014 : }
5015 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5016 : }
5017 0 : resultobj = SWIG_Py_Void();
5018 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5019 : return resultobj;
5020 : fail:
5021 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5022 : return NULL;
5023 : }
5024 :
5025 :
5026 18 : SWIGINTERN PyObject *_wrap__gpgme_engine_info_home_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5027 18 : PyObject *resultobj = 0;
5028 18 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5029 18 : void *argp1 = 0 ;
5030 18 : int res1 = 0 ;
5031 18 : PyObject * obj0 = 0 ;
5032 18 : char *result = 0 ;
5033 :
5034 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_engine_info_home_dir_get",&obj0)) SWIG_fail;
5035 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
5036 18 : if (!SWIG_IsOK(res1)) {
5037 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_engine_info_home_dir_get" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5038 : }
5039 18 : arg1 = (struct _gpgme_engine_info *)(argp1);
5040 : {
5041 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5042 18 : result = (char *) ((arg1)->home_dir);
5043 18 : SWIG_PYTHON_THREAD_END_ALLOW;
5044 : }
5045 18 : resultobj = SWIG_FromCharPtr((const char *)result);
5046 18 : return resultobj;
5047 : fail:
5048 : return NULL;
5049 : }
5050 :
5051 :
5052 0 : SWIGINTERN PyObject *_wrap_new__gpgme_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5053 0 : PyObject *resultobj = 0;
5054 0 : struct _gpgme_engine_info *result = 0 ;
5055 :
5056 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_engine_info")) SWIG_fail;
5057 : {
5058 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5059 0 : result = (struct _gpgme_engine_info *)calloc(1, sizeof(struct _gpgme_engine_info));
5060 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5061 : }
5062 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_engine_info, SWIG_POINTER_NEW | 0 );
5063 0 : return resultobj;
5064 : fail:
5065 : return NULL;
5066 : }
5067 :
5068 :
5069 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5070 0 : PyObject *resultobj = 0;
5071 0 : struct _gpgme_engine_info *arg1 = (struct _gpgme_engine_info *) 0 ;
5072 0 : void *argp1 = 0 ;
5073 0 : int res1 = 0 ;
5074 0 : PyObject * obj0 = 0 ;
5075 :
5076 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_engine_info",&obj0)) SWIG_fail;
5077 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, SWIG_POINTER_DISOWN | 0 );
5078 0 : if (!SWIG_IsOK(res1)) {
5079 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_engine_info" "', argument " "1"" of type '" "struct _gpgme_engine_info *""'");
5080 : }
5081 0 : arg1 = (struct _gpgme_engine_info *)(argp1);
5082 : {
5083 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5084 0 : free((char *) arg1);
5085 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5086 : }
5087 0 : resultobj = SWIG_Py_Void();
5088 0 : return resultobj;
5089 : fail:
5090 : return NULL;
5091 : }
5092 :
5093 :
5094 27 : SWIGINTERN PyObject *_gpgme_engine_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5095 : PyObject *obj;
5096 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5097 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_engine_info, SWIG_NewClientData(obj));
5098 27 : return SWIG_Py_Void();
5099 : }
5100 :
5101 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5102 0 : PyObject *resultobj = 0;
5103 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5104 : unsigned int arg2 ;
5105 0 : void *argp1 = 0 ;
5106 0 : int res1 = 0 ;
5107 : unsigned int val2 ;
5108 0 : int ecode2 = 0 ;
5109 0 : PyObject * obj0 = 0 ;
5110 0 : PyObject * obj1 = 0 ;
5111 :
5112 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_validity_set",&obj0,&obj1)) SWIG_fail;
5113 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5114 0 : if (!SWIG_IsOK(res1)) {
5115 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5116 : }
5117 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5118 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5119 0 : if (!SWIG_IsOK(ecode2)) {
5120 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_validity_set" "', argument " "2"" of type '" "unsigned int""'");
5121 : }
5122 0 : arg2 = (unsigned int)(val2);
5123 : {
5124 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5125 0 : if (arg1) (arg1)->validity = arg2;
5126 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5127 : }
5128 0 : resultobj = SWIG_Py_Void();
5129 0 : return resultobj;
5130 : fail:
5131 : return NULL;
5132 : }
5133 :
5134 :
5135 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5136 0 : PyObject *resultobj = 0;
5137 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5138 0 : void *argp1 = 0 ;
5139 0 : int res1 = 0 ;
5140 0 : PyObject * obj0 = 0 ;
5141 : unsigned int result;
5142 :
5143 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_validity_get",&obj0)) SWIG_fail;
5144 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5145 0 : if (!SWIG_IsOK(res1)) {
5146 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_validity_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5147 : }
5148 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5149 : {
5150 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5151 0 : result = (unsigned int) ((arg1)->validity);
5152 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5153 : }
5154 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5155 0 : return resultobj;
5156 : fail:
5157 : return NULL;
5158 : }
5159 :
5160 :
5161 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5162 0 : PyObject *resultobj = 0;
5163 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5164 : unsigned int arg2 ;
5165 0 : void *argp1 = 0 ;
5166 0 : int res1 = 0 ;
5167 : unsigned int val2 ;
5168 0 : int ecode2 = 0 ;
5169 0 : PyObject * obj0 = 0 ;
5170 0 : PyObject * obj1 = 0 ;
5171 :
5172 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_policy_set",&obj0,&obj1)) SWIG_fail;
5173 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5174 0 : if (!SWIG_IsOK(res1)) {
5175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5176 : }
5177 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5178 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5179 0 : if (!SWIG_IsOK(ecode2)) {
5180 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_policy_set" "', argument " "2"" of type '" "unsigned int""'");
5181 : }
5182 0 : arg2 = (unsigned int)(val2);
5183 : {
5184 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5185 0 : if (arg1) (arg1)->policy = arg2;
5186 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5187 : }
5188 0 : resultobj = SWIG_Py_Void();
5189 0 : return resultobj;
5190 : fail:
5191 : return NULL;
5192 : }
5193 :
5194 :
5195 4 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_policy_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5196 4 : PyObject *resultobj = 0;
5197 4 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5198 4 : void *argp1 = 0 ;
5199 4 : int res1 = 0 ;
5200 4 : PyObject * obj0 = 0 ;
5201 : unsigned int result;
5202 :
5203 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_policy_get",&obj0)) SWIG_fail;
5204 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5205 4 : if (!SWIG_IsOK(res1)) {
5206 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_policy_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5207 : }
5208 4 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5209 : {
5210 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5211 4 : result = (unsigned int) ((arg1)->policy);
5212 4 : SWIG_PYTHON_THREAD_END_ALLOW;
5213 : }
5214 4 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5215 4 : return resultobj;
5216 : fail:
5217 : return NULL;
5218 : }
5219 :
5220 :
5221 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5222 0 : PyObject *resultobj = 0;
5223 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5224 : unsigned int arg2 ;
5225 0 : void *argp1 = 0 ;
5226 0 : int res1 = 0 ;
5227 : unsigned int val2 ;
5228 0 : int ecode2 = 0 ;
5229 0 : PyObject * obj0 = 0 ;
5230 0 : PyObject * obj1 = 0 ;
5231 :
5232 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info__rfu_set",&obj0,&obj1)) SWIG_fail;
5233 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5234 0 : if (!SWIG_IsOK(res1)) {
5235 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5236 : }
5237 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5238 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5239 0 : if (!SWIG_IsOK(ecode2)) {
5240 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info__rfu_set" "', argument " "2"" of type '" "unsigned int""'");
5241 : }
5242 0 : arg2 = (unsigned int)(val2);
5243 : {
5244 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5245 0 : if (arg1) (arg1)->_rfu = arg2;
5246 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5247 : }
5248 0 : resultobj = SWIG_Py_Void();
5249 0 : return resultobj;
5250 : fail:
5251 : return NULL;
5252 : }
5253 :
5254 :
5255 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info__rfu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5256 0 : PyObject *resultobj = 0;
5257 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5258 0 : void *argp1 = 0 ;
5259 0 : int res1 = 0 ;
5260 0 : PyObject * obj0 = 0 ;
5261 : unsigned int result;
5262 :
5263 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info__rfu_get",&obj0)) SWIG_fail;
5264 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5265 0 : if (!SWIG_IsOK(res1)) {
5266 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info__rfu_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5267 : }
5268 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5269 : {
5270 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5271 0 : result = (unsigned int) ((arg1)->_rfu);
5272 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5273 : }
5274 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5275 0 : return resultobj;
5276 : fail:
5277 : return NULL;
5278 : }
5279 :
5280 :
5281 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5282 0 : PyObject *resultobj = 0;
5283 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5284 : unsigned short arg2 ;
5285 0 : void *argp1 = 0 ;
5286 0 : int res1 = 0 ;
5287 : unsigned short val2 ;
5288 0 : int ecode2 = 0 ;
5289 0 : PyObject * obj0 = 0 ;
5290 0 : PyObject * obj1 = 0 ;
5291 :
5292 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signcount_set",&obj0,&obj1)) SWIG_fail;
5293 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5294 0 : if (!SWIG_IsOK(res1)) {
5295 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5296 : }
5297 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5298 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5299 0 : if (!SWIG_IsOK(ecode2)) {
5300 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signcount_set" "', argument " "2"" of type '" "unsigned short""'");
5301 : }
5302 0 : arg2 = (unsigned short)(val2);
5303 : {
5304 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5305 0 : if (arg1) (arg1)->signcount = arg2;
5306 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5307 : }
5308 0 : resultobj = SWIG_Py_Void();
5309 0 : return resultobj;
5310 : fail:
5311 : return NULL;
5312 : }
5313 :
5314 :
5315 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5316 0 : PyObject *resultobj = 0;
5317 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5318 0 : void *argp1 = 0 ;
5319 0 : int res1 = 0 ;
5320 0 : PyObject * obj0 = 0 ;
5321 : unsigned short result;
5322 :
5323 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signcount_get",&obj0)) SWIG_fail;
5324 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5325 0 : if (!SWIG_IsOK(res1)) {
5326 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5327 : }
5328 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5329 : {
5330 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5331 0 : result = (unsigned short) ((arg1)->signcount);
5332 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5333 : }
5334 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5335 0 : return resultobj;
5336 : fail:
5337 : return NULL;
5338 : }
5339 :
5340 :
5341 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5342 0 : PyObject *resultobj = 0;
5343 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5344 : unsigned short arg2 ;
5345 0 : void *argp1 = 0 ;
5346 0 : int res1 = 0 ;
5347 : unsigned short val2 ;
5348 0 : int ecode2 = 0 ;
5349 0 : PyObject * obj0 = 0 ;
5350 0 : PyObject * obj1 = 0 ;
5351 :
5352 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrcount_set",&obj0,&obj1)) SWIG_fail;
5353 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5354 0 : if (!SWIG_IsOK(res1)) {
5355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5356 : }
5357 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5358 0 : ecode2 = SWIG_AsVal_unsigned_SS_short(obj1, &val2);
5359 0 : if (!SWIG_IsOK(ecode2)) {
5360 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrcount_set" "', argument " "2"" of type '" "unsigned short""'");
5361 : }
5362 0 : arg2 = (unsigned short)(val2);
5363 : {
5364 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5365 0 : if (arg1) (arg1)->encrcount = arg2;
5366 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5367 : }
5368 0 : resultobj = SWIG_Py_Void();
5369 0 : return resultobj;
5370 : fail:
5371 : return NULL;
5372 : }
5373 :
5374 :
5375 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrcount_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5376 0 : PyObject *resultobj = 0;
5377 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5378 0 : void *argp1 = 0 ;
5379 0 : int res1 = 0 ;
5380 0 : PyObject * obj0 = 0 ;
5381 : unsigned short result;
5382 :
5383 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrcount_get",&obj0)) SWIG_fail;
5384 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5385 0 : if (!SWIG_IsOK(res1)) {
5386 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrcount_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5387 : }
5388 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5389 : {
5390 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5391 0 : result = (unsigned short) ((arg1)->encrcount);
5392 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5393 : }
5394 0 : resultobj = SWIG_From_unsigned_SS_short((unsigned short)(result));
5395 0 : return resultobj;
5396 : fail:
5397 : return NULL;
5398 : }
5399 :
5400 :
5401 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5402 0 : PyObject *resultobj = 0;
5403 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5404 : unsigned long arg2 ;
5405 0 : void *argp1 = 0 ;
5406 0 : int res1 = 0 ;
5407 : unsigned long val2 ;
5408 0 : int ecode2 = 0 ;
5409 0 : PyObject * obj0 = 0 ;
5410 0 : PyObject * obj1 = 0 ;
5411 :
5412 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signfirst_set",&obj0,&obj1)) SWIG_fail;
5413 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5414 0 : if (!SWIG_IsOK(res1)) {
5415 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5416 : }
5417 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5418 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5419 0 : if (!SWIG_IsOK(ecode2)) {
5420 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5421 : }
5422 0 : arg2 = (unsigned long)(val2);
5423 : {
5424 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5425 0 : if (arg1) (arg1)->signfirst = arg2;
5426 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5427 : }
5428 0 : resultobj = SWIG_Py_Void();
5429 0 : return resultobj;
5430 : fail:
5431 : return NULL;
5432 : }
5433 :
5434 :
5435 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signfirst_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5436 0 : PyObject *resultobj = 0;
5437 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5438 0 : void *argp1 = 0 ;
5439 0 : int res1 = 0 ;
5440 0 : PyObject * obj0 = 0 ;
5441 : unsigned long result;
5442 :
5443 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signfirst_get",&obj0)) SWIG_fail;
5444 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5445 0 : if (!SWIG_IsOK(res1)) {
5446 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5447 : }
5448 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5449 : {
5450 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5451 0 : result = (unsigned long) ((arg1)->signfirst);
5452 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5453 : }
5454 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5455 0 : return resultobj;
5456 : fail:
5457 : return NULL;
5458 : }
5459 :
5460 :
5461 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5462 0 : PyObject *resultobj = 0;
5463 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5464 : unsigned long arg2 ;
5465 0 : void *argp1 = 0 ;
5466 0 : int res1 = 0 ;
5467 : unsigned long val2 ;
5468 0 : int ecode2 = 0 ;
5469 0 : PyObject * obj0 = 0 ;
5470 0 : PyObject * obj1 = 0 ;
5471 :
5472 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_signlast_set",&obj0,&obj1)) SWIG_fail;
5473 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5474 0 : if (!SWIG_IsOK(res1)) {
5475 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5476 : }
5477 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5478 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5479 0 : if (!SWIG_IsOK(ecode2)) {
5480 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_signlast_set" "', argument " "2"" of type '" "unsigned long""'");
5481 : }
5482 0 : arg2 = (unsigned long)(val2);
5483 : {
5484 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5485 0 : if (arg1) (arg1)->signlast = arg2;
5486 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5487 : }
5488 0 : resultobj = SWIG_Py_Void();
5489 0 : return resultobj;
5490 : fail:
5491 : return NULL;
5492 : }
5493 :
5494 :
5495 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_signlast_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5496 0 : PyObject *resultobj = 0;
5497 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5498 0 : void *argp1 = 0 ;
5499 0 : int res1 = 0 ;
5500 0 : PyObject * obj0 = 0 ;
5501 : unsigned long result;
5502 :
5503 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_signlast_get",&obj0)) SWIG_fail;
5504 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5505 0 : if (!SWIG_IsOK(res1)) {
5506 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_signlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5507 : }
5508 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5509 : {
5510 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5511 0 : result = (unsigned long) ((arg1)->signlast);
5512 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5513 : }
5514 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5515 0 : return resultobj;
5516 : fail:
5517 : return NULL;
5518 : }
5519 :
5520 :
5521 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5522 0 : PyObject *resultobj = 0;
5523 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5524 : unsigned long arg2 ;
5525 0 : void *argp1 = 0 ;
5526 0 : int res1 = 0 ;
5527 : unsigned long val2 ;
5528 0 : int ecode2 = 0 ;
5529 0 : PyObject * obj0 = 0 ;
5530 0 : PyObject * obj1 = 0 ;
5531 :
5532 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrfirst_set",&obj0,&obj1)) SWIG_fail;
5533 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5534 0 : if (!SWIG_IsOK(res1)) {
5535 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5536 : }
5537 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5538 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5539 0 : if (!SWIG_IsOK(ecode2)) {
5540 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrfirst_set" "', argument " "2"" of type '" "unsigned long""'");
5541 : }
5542 0 : arg2 = (unsigned long)(val2);
5543 : {
5544 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5545 0 : if (arg1) (arg1)->encrfirst = arg2;
5546 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5547 : }
5548 0 : resultobj = SWIG_Py_Void();
5549 0 : return resultobj;
5550 : fail:
5551 : return NULL;
5552 : }
5553 :
5554 :
5555 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrfirst_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5556 0 : PyObject *resultobj = 0;
5557 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5558 0 : void *argp1 = 0 ;
5559 0 : int res1 = 0 ;
5560 0 : PyObject * obj0 = 0 ;
5561 : unsigned long result;
5562 :
5563 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrfirst_get",&obj0)) SWIG_fail;
5564 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5565 0 : if (!SWIG_IsOK(res1)) {
5566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrfirst_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5567 : }
5568 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5569 : {
5570 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5571 0 : result = (unsigned long) ((arg1)->encrfirst);
5572 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5573 : }
5574 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5575 0 : return resultobj;
5576 : fail:
5577 : return NULL;
5578 : }
5579 :
5580 :
5581 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5582 0 : PyObject *resultobj = 0;
5583 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5584 : unsigned long arg2 ;
5585 0 : void *argp1 = 0 ;
5586 0 : int res1 = 0 ;
5587 : unsigned long val2 ;
5588 0 : int ecode2 = 0 ;
5589 0 : PyObject * obj0 = 0 ;
5590 0 : PyObject * obj1 = 0 ;
5591 :
5592 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_encrlast_set",&obj0,&obj1)) SWIG_fail;
5593 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5594 0 : if (!SWIG_IsOK(res1)) {
5595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5596 : }
5597 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5598 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
5599 0 : if (!SWIG_IsOK(ecode2)) {
5600 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_tofu_info_encrlast_set" "', argument " "2"" of type '" "unsigned long""'");
5601 : }
5602 0 : arg2 = (unsigned long)(val2);
5603 : {
5604 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5605 0 : if (arg1) (arg1)->encrlast = arg2;
5606 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5607 : }
5608 0 : resultobj = SWIG_Py_Void();
5609 0 : return resultobj;
5610 : fail:
5611 : return NULL;
5612 : }
5613 :
5614 :
5615 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_encrlast_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5616 0 : PyObject *resultobj = 0;
5617 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5618 0 : void *argp1 = 0 ;
5619 0 : int res1 = 0 ;
5620 0 : PyObject * obj0 = 0 ;
5621 : unsigned long result;
5622 :
5623 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_encrlast_get",&obj0)) SWIG_fail;
5624 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5625 0 : if (!SWIG_IsOK(res1)) {
5626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_encrlast_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5627 : }
5628 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5629 : {
5630 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5631 0 : result = (unsigned long) ((arg1)->encrlast);
5632 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5633 : }
5634 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
5635 0 : return resultobj;
5636 : fail:
5637 : return NULL;
5638 : }
5639 :
5640 :
5641 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5642 0 : PyObject *resultobj = 0;
5643 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5644 0 : char *arg2 = (char *) 0 ;
5645 0 : void *argp1 = 0 ;
5646 0 : int res1 = 0 ;
5647 : int res2 ;
5648 0 : char *buf2 = 0 ;
5649 0 : int alloc2 = 0 ;
5650 0 : PyObject * obj0 = 0 ;
5651 0 : PyObject * obj1 = 0 ;
5652 :
5653 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_tofu_info_description_set",&obj0,&obj1)) SWIG_fail;
5654 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5655 0 : if (!SWIG_IsOK(res1)) {
5656 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_set" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5657 : }
5658 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5659 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
5660 0 : if (!SWIG_IsOK(res2)) {
5661 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_tofu_info_description_set" "', argument " "2"" of type '" "char *""'");
5662 : }
5663 0 : arg2 = (char *)(buf2);
5664 : {
5665 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5666 0 : if (arg1->description) free((char*)arg1->description);
5667 0 : if (arg2) {
5668 0 : size_t size = strlen((const char *)(arg2)) + 1;
5669 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
5670 : } else {
5671 0 : arg1->description = 0;
5672 : }
5673 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5674 : }
5675 0 : resultobj = SWIG_Py_Void();
5676 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5677 : return resultobj;
5678 : fail:
5679 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
5680 : return NULL;
5681 : }
5682 :
5683 :
5684 0 : SWIGINTERN PyObject *_wrap__gpgme_tofu_info_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5685 0 : PyObject *resultobj = 0;
5686 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5687 0 : void *argp1 = 0 ;
5688 0 : int res1 = 0 ;
5689 0 : PyObject * obj0 = 0 ;
5690 0 : char *result = 0 ;
5691 :
5692 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_tofu_info_description_get",&obj0)) SWIG_fail;
5693 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, 0 | 0 );
5694 0 : if (!SWIG_IsOK(res1)) {
5695 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_tofu_info_description_get" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5696 : }
5697 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5698 : {
5699 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5700 0 : result = (char *) ((arg1)->description);
5701 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5702 : }
5703 0 : resultobj = SWIG_FromCharPtr((const char *)result);
5704 0 : return resultobj;
5705 : fail:
5706 : return NULL;
5707 : }
5708 :
5709 :
5710 0 : SWIGINTERN PyObject *_wrap_new__gpgme_tofu_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5711 0 : PyObject *resultobj = 0;
5712 0 : struct _gpgme_tofu_info *result = 0 ;
5713 :
5714 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_tofu_info")) SWIG_fail;
5715 : {
5716 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5717 0 : result = (struct _gpgme_tofu_info *)calloc(1, sizeof(struct _gpgme_tofu_info));
5718 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5719 : }
5720 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_NEW | 0 );
5721 0 : return resultobj;
5722 : fail:
5723 : return NULL;
5724 : }
5725 :
5726 :
5727 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_tofu_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5728 0 : PyObject *resultobj = 0;
5729 0 : struct _gpgme_tofu_info *arg1 = (struct _gpgme_tofu_info *) 0 ;
5730 0 : void *argp1 = 0 ;
5731 0 : int res1 = 0 ;
5732 0 : PyObject * obj0 = 0 ;
5733 :
5734 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_tofu_info",&obj0)) SWIG_fail;
5735 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
5736 0 : if (!SWIG_IsOK(res1)) {
5737 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_tofu_info" "', argument " "1"" of type '" "struct _gpgme_tofu_info *""'");
5738 : }
5739 0 : arg1 = (struct _gpgme_tofu_info *)(argp1);
5740 : {
5741 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5742 0 : free((char *) arg1);
5743 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5744 : }
5745 0 : resultobj = SWIG_Py_Void();
5746 0 : return resultobj;
5747 : fail:
5748 : return NULL;
5749 : }
5750 :
5751 :
5752 27 : SWIGINTERN PyObject *_gpgme_tofu_info_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5753 : PyObject *obj;
5754 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
5755 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_tofu_info, SWIG_NewClientData(obj));
5756 27 : return SWIG_Py_Void();
5757 : }
5758 :
5759 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5760 0 : PyObject *resultobj = 0;
5761 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5762 : unsigned int arg2 ;
5763 0 : void *argp1 = 0 ;
5764 0 : int res1 = 0 ;
5765 : unsigned int val2 ;
5766 0 : int ecode2 = 0 ;
5767 0 : PyObject * obj0 = 0 ;
5768 0 : PyObject * obj1 = 0 ;
5769 :
5770 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_revoked_set",&obj0,&obj1)) SWIG_fail;
5771 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5772 0 : if (!SWIG_IsOK(res1)) {
5773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5774 : }
5775 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5776 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5777 0 : if (!SWIG_IsOK(ecode2)) {
5778 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
5779 : }
5780 0 : arg2 = (unsigned int)(val2);
5781 : {
5782 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5783 0 : if (arg1) (arg1)->revoked = arg2;
5784 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5785 : }
5786 0 : resultobj = SWIG_Py_Void();
5787 0 : return resultobj;
5788 : fail:
5789 : return NULL;
5790 : }
5791 :
5792 :
5793 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 104 : PyObject *resultobj = 0;
5795 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5796 104 : void *argp1 = 0 ;
5797 104 : int res1 = 0 ;
5798 104 : PyObject * obj0 = 0 ;
5799 : unsigned int result;
5800 :
5801 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_revoked_get",&obj0)) SWIG_fail;
5802 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5803 104 : if (!SWIG_IsOK(res1)) {
5804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_revoked_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5805 : }
5806 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5807 : {
5808 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5809 104 : result = (unsigned int) ((arg1)->revoked);
5810 104 : SWIG_PYTHON_THREAD_END_ALLOW;
5811 : }
5812 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5813 104 : return resultobj;
5814 : fail:
5815 : return NULL;
5816 : }
5817 :
5818 :
5819 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5820 0 : PyObject *resultobj = 0;
5821 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5822 : unsigned int arg2 ;
5823 0 : void *argp1 = 0 ;
5824 0 : int res1 = 0 ;
5825 : unsigned int val2 ;
5826 0 : int ecode2 = 0 ;
5827 0 : PyObject * obj0 = 0 ;
5828 0 : PyObject * obj1 = 0 ;
5829 :
5830 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_expired_set",&obj0,&obj1)) SWIG_fail;
5831 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5832 0 : if (!SWIG_IsOK(res1)) {
5833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5834 : }
5835 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5836 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5837 0 : if (!SWIG_IsOK(ecode2)) {
5838 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expired_set" "', argument " "2"" of type '" "unsigned int""'");
5839 : }
5840 0 : arg2 = (unsigned int)(val2);
5841 : {
5842 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5843 0 : if (arg1) (arg1)->expired = arg2;
5844 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5845 : }
5846 0 : resultobj = SWIG_Py_Void();
5847 0 : return resultobj;
5848 : fail:
5849 : return NULL;
5850 : }
5851 :
5852 :
5853 108 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5854 108 : PyObject *resultobj = 0;
5855 108 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5856 108 : void *argp1 = 0 ;
5857 108 : int res1 = 0 ;
5858 108 : PyObject * obj0 = 0 ;
5859 : unsigned int result;
5860 :
5861 108 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expired_get",&obj0)) SWIG_fail;
5862 108 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5863 108 : if (!SWIG_IsOK(res1)) {
5864 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expired_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5865 : }
5866 108 : arg1 = (struct _gpgme_subkey *)(argp1);
5867 : {
5868 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5869 108 : result = (unsigned int) ((arg1)->expired);
5870 108 : SWIG_PYTHON_THREAD_END_ALLOW;
5871 : }
5872 108 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5873 108 : return resultobj;
5874 : fail:
5875 : return NULL;
5876 : }
5877 :
5878 :
5879 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5880 0 : PyObject *resultobj = 0;
5881 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5882 : unsigned int arg2 ;
5883 0 : void *argp1 = 0 ;
5884 0 : int res1 = 0 ;
5885 : unsigned int val2 ;
5886 0 : int ecode2 = 0 ;
5887 0 : PyObject * obj0 = 0 ;
5888 0 : PyObject * obj1 = 0 ;
5889 :
5890 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_disabled_set",&obj0,&obj1)) SWIG_fail;
5891 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5892 0 : if (!SWIG_IsOK(res1)) {
5893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5894 : }
5895 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5896 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5897 0 : if (!SWIG_IsOK(ecode2)) {
5898 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
5899 : }
5900 0 : arg2 = (unsigned int)(val2);
5901 : {
5902 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5903 0 : if (arg1) (arg1)->disabled = arg2;
5904 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5905 : }
5906 0 : resultobj = SWIG_Py_Void();
5907 0 : return resultobj;
5908 : fail:
5909 : return NULL;
5910 : }
5911 :
5912 :
5913 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_disabled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5914 104 : PyObject *resultobj = 0;
5915 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5916 104 : void *argp1 = 0 ;
5917 104 : int res1 = 0 ;
5918 104 : PyObject * obj0 = 0 ;
5919 : unsigned int result;
5920 :
5921 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_disabled_get",&obj0)) SWIG_fail;
5922 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5923 104 : if (!SWIG_IsOK(res1)) {
5924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_disabled_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5925 : }
5926 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5927 : {
5928 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5929 104 : result = (unsigned int) ((arg1)->disabled);
5930 104 : SWIG_PYTHON_THREAD_END_ALLOW;
5931 : }
5932 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5933 104 : return resultobj;
5934 : fail:
5935 : return NULL;
5936 : }
5937 :
5938 :
5939 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5940 0 : PyObject *resultobj = 0;
5941 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5942 : unsigned int arg2 ;
5943 0 : void *argp1 = 0 ;
5944 0 : int res1 = 0 ;
5945 : unsigned int val2 ;
5946 0 : int ecode2 = 0 ;
5947 0 : PyObject * obj0 = 0 ;
5948 0 : PyObject * obj1 = 0 ;
5949 :
5950 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_invalid_set",&obj0,&obj1)) SWIG_fail;
5951 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5952 0 : if (!SWIG_IsOK(res1)) {
5953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5954 : }
5955 0 : arg1 = (struct _gpgme_subkey *)(argp1);
5956 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
5957 0 : if (!SWIG_IsOK(ecode2)) {
5958 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
5959 : }
5960 0 : arg2 = (unsigned int)(val2);
5961 : {
5962 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5963 0 : if (arg1) (arg1)->invalid = arg2;
5964 0 : SWIG_PYTHON_THREAD_END_ALLOW;
5965 : }
5966 0 : resultobj = SWIG_Py_Void();
5967 0 : return resultobj;
5968 : fail:
5969 : return NULL;
5970 : }
5971 :
5972 :
5973 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5974 104 : PyObject *resultobj = 0;
5975 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
5976 104 : void *argp1 = 0 ;
5977 104 : int res1 = 0 ;
5978 104 : PyObject * obj0 = 0 ;
5979 : unsigned int result;
5980 :
5981 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_invalid_get",&obj0)) SWIG_fail;
5982 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
5983 104 : if (!SWIG_IsOK(res1)) {
5984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_invalid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
5985 : }
5986 104 : arg1 = (struct _gpgme_subkey *)(argp1);
5987 : {
5988 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
5989 104 : result = (unsigned int) ((arg1)->invalid);
5990 104 : SWIG_PYTHON_THREAD_END_ALLOW;
5991 : }
5992 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
5993 104 : return resultobj;
5994 : fail:
5995 : return NULL;
5996 : }
5997 :
5998 :
5999 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6000 0 : PyObject *resultobj = 0;
6001 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6002 : unsigned int arg2 ;
6003 0 : void *argp1 = 0 ;
6004 0 : int res1 = 0 ;
6005 : unsigned int val2 ;
6006 0 : int ecode2 = 0 ;
6007 0 : PyObject * obj0 = 0 ;
6008 0 : PyObject * obj1 = 0 ;
6009 :
6010 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_encrypt_set",&obj0,&obj1)) SWIG_fail;
6011 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6012 0 : if (!SWIG_IsOK(res1)) {
6013 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6014 : }
6015 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6016 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6017 0 : if (!SWIG_IsOK(ecode2)) {
6018 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
6019 : }
6020 0 : arg2 = (unsigned int)(val2);
6021 : {
6022 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6023 0 : if (arg1) (arg1)->can_encrypt = arg2;
6024 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6025 : }
6026 0 : resultobj = SWIG_Py_Void();
6027 0 : return resultobj;
6028 : fail:
6029 : return NULL;
6030 : }
6031 :
6032 :
6033 120 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_encrypt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6034 120 : PyObject *resultobj = 0;
6035 120 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6036 120 : void *argp1 = 0 ;
6037 120 : int res1 = 0 ;
6038 120 : PyObject * obj0 = 0 ;
6039 : unsigned int result;
6040 :
6041 120 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_encrypt_get",&obj0)) SWIG_fail;
6042 120 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6043 120 : if (!SWIG_IsOK(res1)) {
6044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6045 : }
6046 120 : arg1 = (struct _gpgme_subkey *)(argp1);
6047 : {
6048 120 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6049 120 : result = (unsigned int) ((arg1)->can_encrypt);
6050 120 : SWIG_PYTHON_THREAD_END_ALLOW;
6051 : }
6052 120 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6053 120 : return resultobj;
6054 : fail:
6055 : return NULL;
6056 : }
6057 :
6058 :
6059 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6060 0 : PyObject *resultobj = 0;
6061 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6062 : unsigned int arg2 ;
6063 0 : void *argp1 = 0 ;
6064 0 : int res1 = 0 ;
6065 : unsigned int val2 ;
6066 0 : int ecode2 = 0 ;
6067 0 : PyObject * obj0 = 0 ;
6068 0 : PyObject * obj1 = 0 ;
6069 :
6070 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_sign_set",&obj0,&obj1)) SWIG_fail;
6071 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6072 0 : if (!SWIG_IsOK(res1)) {
6073 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6074 : }
6075 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6076 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6077 0 : if (!SWIG_IsOK(ecode2)) {
6078 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
6079 : }
6080 0 : arg2 = (unsigned int)(val2);
6081 : {
6082 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6083 0 : if (arg1) (arg1)->can_sign = arg2;
6084 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6085 : }
6086 0 : resultobj = SWIG_Py_Void();
6087 0 : return resultobj;
6088 : fail:
6089 : return NULL;
6090 : }
6091 :
6092 :
6093 127 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_sign_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6094 127 : PyObject *resultobj = 0;
6095 127 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6096 127 : void *argp1 = 0 ;
6097 127 : int res1 = 0 ;
6098 127 : PyObject * obj0 = 0 ;
6099 : unsigned int result;
6100 :
6101 127 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_sign_get",&obj0)) SWIG_fail;
6102 127 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6103 127 : if (!SWIG_IsOK(res1)) {
6104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6105 : }
6106 127 : arg1 = (struct _gpgme_subkey *)(argp1);
6107 : {
6108 127 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6109 127 : result = (unsigned int) ((arg1)->can_sign);
6110 127 : SWIG_PYTHON_THREAD_END_ALLOW;
6111 : }
6112 127 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6113 127 : return resultobj;
6114 : fail:
6115 : return NULL;
6116 : }
6117 :
6118 :
6119 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6120 0 : PyObject *resultobj = 0;
6121 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6122 : unsigned int arg2 ;
6123 0 : void *argp1 = 0 ;
6124 0 : int res1 = 0 ;
6125 : unsigned int val2 ;
6126 0 : int ecode2 = 0 ;
6127 0 : PyObject * obj0 = 0 ;
6128 0 : PyObject * obj1 = 0 ;
6129 :
6130 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_certify_set",&obj0,&obj1)) SWIG_fail;
6131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6132 0 : if (!SWIG_IsOK(res1)) {
6133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6134 : }
6135 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6136 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6137 0 : if (!SWIG_IsOK(ecode2)) {
6138 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
6139 : }
6140 0 : arg2 = (unsigned int)(val2);
6141 : {
6142 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6143 0 : if (arg1) (arg1)->can_certify = arg2;
6144 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6145 : }
6146 0 : resultobj = SWIG_Py_Void();
6147 0 : return resultobj;
6148 : fail:
6149 : return NULL;
6150 : }
6151 :
6152 :
6153 112 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_certify_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6154 112 : PyObject *resultobj = 0;
6155 112 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6156 112 : void *argp1 = 0 ;
6157 112 : int res1 = 0 ;
6158 112 : PyObject * obj0 = 0 ;
6159 : unsigned int result;
6160 :
6161 112 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_certify_get",&obj0)) SWIG_fail;
6162 112 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6163 112 : if (!SWIG_IsOK(res1)) {
6164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6165 : }
6166 112 : arg1 = (struct _gpgme_subkey *)(argp1);
6167 : {
6168 112 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6169 112 : result = (unsigned int) ((arg1)->can_certify);
6170 112 : SWIG_PYTHON_THREAD_END_ALLOW;
6171 : }
6172 112 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6173 112 : return resultobj;
6174 : fail:
6175 : return NULL;
6176 : }
6177 :
6178 :
6179 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6180 0 : PyObject *resultobj = 0;
6181 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6182 : unsigned int arg2 ;
6183 0 : void *argp1 = 0 ;
6184 0 : int res1 = 0 ;
6185 : unsigned int val2 ;
6186 0 : int ecode2 = 0 ;
6187 0 : PyObject * obj0 = 0 ;
6188 0 : PyObject * obj1 = 0 ;
6189 :
6190 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_secret_set",&obj0,&obj1)) SWIG_fail;
6191 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6192 0 : if (!SWIG_IsOK(res1)) {
6193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6194 : }
6195 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6196 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6197 0 : if (!SWIG_IsOK(ecode2)) {
6198 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_secret_set" "', argument " "2"" of type '" "unsigned int""'");
6199 : }
6200 0 : arg2 = (unsigned int)(val2);
6201 : {
6202 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6203 0 : if (arg1) (arg1)->secret = arg2;
6204 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6205 : }
6206 0 : resultobj = SWIG_Py_Void();
6207 0 : return resultobj;
6208 : fail:
6209 : return NULL;
6210 : }
6211 :
6212 :
6213 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_secret_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6214 104 : PyObject *resultobj = 0;
6215 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6216 104 : void *argp1 = 0 ;
6217 104 : int res1 = 0 ;
6218 104 : PyObject * obj0 = 0 ;
6219 : unsigned int result;
6220 :
6221 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_secret_get",&obj0)) SWIG_fail;
6222 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6223 104 : if (!SWIG_IsOK(res1)) {
6224 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_secret_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6225 : }
6226 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6227 : {
6228 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6229 104 : result = (unsigned int) ((arg1)->secret);
6230 104 : SWIG_PYTHON_THREAD_END_ALLOW;
6231 : }
6232 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6233 104 : return resultobj;
6234 : fail:
6235 : return NULL;
6236 : }
6237 :
6238 :
6239 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6240 0 : PyObject *resultobj = 0;
6241 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6242 : unsigned int arg2 ;
6243 0 : void *argp1 = 0 ;
6244 0 : int res1 = 0 ;
6245 : unsigned int val2 ;
6246 0 : int ecode2 = 0 ;
6247 0 : PyObject * obj0 = 0 ;
6248 0 : PyObject * obj1 = 0 ;
6249 :
6250 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_can_authenticate_set",&obj0,&obj1)) SWIG_fail;
6251 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6252 0 : if (!SWIG_IsOK(res1)) {
6253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6254 : }
6255 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6256 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6257 0 : if (!SWIG_IsOK(ecode2)) {
6258 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
6259 : }
6260 0 : arg2 = (unsigned int)(val2);
6261 : {
6262 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6263 0 : if (arg1) (arg1)->can_authenticate = arg2;
6264 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6265 : }
6266 0 : resultobj = SWIG_Py_Void();
6267 0 : return resultobj;
6268 : fail:
6269 : return NULL;
6270 : }
6271 :
6272 :
6273 15 : SWIGINTERN PyObject *_wrap__gpgme_subkey_can_authenticate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6274 15 : PyObject *resultobj = 0;
6275 15 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6276 15 : void *argp1 = 0 ;
6277 15 : int res1 = 0 ;
6278 15 : PyObject * obj0 = 0 ;
6279 : unsigned int result;
6280 :
6281 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_can_authenticate_get",&obj0)) SWIG_fail;
6282 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6283 15 : if (!SWIG_IsOK(res1)) {
6284 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6285 : }
6286 15 : arg1 = (struct _gpgme_subkey *)(argp1);
6287 : {
6288 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6289 15 : result = (unsigned int) ((arg1)->can_authenticate);
6290 15 : SWIG_PYTHON_THREAD_END_ALLOW;
6291 : }
6292 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6293 15 : return resultobj;
6294 : fail:
6295 : return NULL;
6296 : }
6297 :
6298 :
6299 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6300 0 : PyObject *resultobj = 0;
6301 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6302 : unsigned int arg2 ;
6303 0 : void *argp1 = 0 ;
6304 0 : int res1 = 0 ;
6305 : unsigned int val2 ;
6306 0 : int ecode2 = 0 ;
6307 0 : PyObject * obj0 = 0 ;
6308 0 : PyObject * obj1 = 0 ;
6309 :
6310 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_is_qualified_set",&obj0,&obj1)) SWIG_fail;
6311 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6312 0 : if (!SWIG_IsOK(res1)) {
6313 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6314 : }
6315 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6316 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6317 0 : if (!SWIG_IsOK(ecode2)) {
6318 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
6319 : }
6320 0 : arg2 = (unsigned int)(val2);
6321 : {
6322 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6323 0 : if (arg1) (arg1)->is_qualified = arg2;
6324 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6325 : }
6326 0 : resultobj = SWIG_Py_Void();
6327 0 : return resultobj;
6328 : fail:
6329 : return NULL;
6330 : }
6331 :
6332 :
6333 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_qualified_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6334 0 : PyObject *resultobj = 0;
6335 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6336 0 : void *argp1 = 0 ;
6337 0 : int res1 = 0 ;
6338 0 : PyObject * obj0 = 0 ;
6339 : unsigned int result;
6340 :
6341 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_qualified_get",&obj0)) SWIG_fail;
6342 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6343 0 : if (!SWIG_IsOK(res1)) {
6344 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6345 : }
6346 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6347 : {
6348 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6349 0 : result = (unsigned int) ((arg1)->is_qualified);
6350 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6351 : }
6352 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6353 0 : return resultobj;
6354 : fail:
6355 : return NULL;
6356 : }
6357 :
6358 :
6359 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6360 0 : PyObject *resultobj = 0;
6361 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6362 : unsigned int arg2 ;
6363 0 : void *argp1 = 0 ;
6364 0 : int res1 = 0 ;
6365 : unsigned int val2 ;
6366 0 : int ecode2 = 0 ;
6367 0 : PyObject * obj0 = 0 ;
6368 0 : PyObject * obj1 = 0 ;
6369 :
6370 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_is_cardkey_set",&obj0,&obj1)) SWIG_fail;
6371 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6372 0 : if (!SWIG_IsOK(res1)) {
6373 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6374 : }
6375 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6376 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6377 0 : if (!SWIG_IsOK(ecode2)) {
6378 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_is_cardkey_set" "', argument " "2"" of type '" "unsigned int""'");
6379 : }
6380 0 : arg2 = (unsigned int)(val2);
6381 : {
6382 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6383 0 : if (arg1) (arg1)->is_cardkey = arg2;
6384 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6385 : }
6386 0 : resultobj = SWIG_Py_Void();
6387 0 : return resultobj;
6388 : fail:
6389 : return NULL;
6390 : }
6391 :
6392 :
6393 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_is_cardkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6394 104 : PyObject *resultobj = 0;
6395 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6396 104 : void *argp1 = 0 ;
6397 104 : int res1 = 0 ;
6398 104 : PyObject * obj0 = 0 ;
6399 : unsigned int result;
6400 :
6401 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_is_cardkey_get",&obj0)) SWIG_fail;
6402 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6403 104 : if (!SWIG_IsOK(res1)) {
6404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_is_cardkey_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6405 : }
6406 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6407 : {
6408 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6409 104 : result = (unsigned int) ((arg1)->is_cardkey);
6410 104 : SWIG_PYTHON_THREAD_END_ALLOW;
6411 : }
6412 104 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6413 104 : return resultobj;
6414 : fail:
6415 : return NULL;
6416 : }
6417 :
6418 :
6419 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6420 0 : PyObject *resultobj = 0;
6421 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6422 : unsigned int arg2 ;
6423 0 : void *argp1 = 0 ;
6424 0 : int res1 = 0 ;
6425 : unsigned int val2 ;
6426 0 : int ecode2 = 0 ;
6427 0 : PyObject * obj0 = 0 ;
6428 0 : PyObject * obj1 = 0 ;
6429 :
6430 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey__unused_set",&obj0,&obj1)) SWIG_fail;
6431 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6432 0 : if (!SWIG_IsOK(res1)) {
6433 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6434 : }
6435 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6436 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6437 0 : if (!SWIG_IsOK(ecode2)) {
6438 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey__unused_set" "', argument " "2"" of type '" "unsigned int""'");
6439 : }
6440 0 : arg2 = (unsigned int)(val2);
6441 : {
6442 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6443 0 : if (arg1) (arg1)->_unused = arg2;
6444 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6445 : }
6446 0 : resultobj = SWIG_Py_Void();
6447 0 : return resultobj;
6448 : fail:
6449 : return NULL;
6450 : }
6451 :
6452 :
6453 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6454 0 : PyObject *resultobj = 0;
6455 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6456 0 : void *argp1 = 0 ;
6457 0 : int res1 = 0 ;
6458 0 : PyObject * obj0 = 0 ;
6459 : unsigned int result;
6460 :
6461 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__unused_get",&obj0)) SWIG_fail;
6462 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6463 0 : if (!SWIG_IsOK(res1)) {
6464 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__unused_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6465 : }
6466 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6467 : {
6468 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6469 0 : result = (unsigned int) ((arg1)->_unused);
6470 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6471 : }
6472 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6473 0 : return resultobj;
6474 : fail:
6475 : return NULL;
6476 : }
6477 :
6478 :
6479 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6480 0 : PyObject *resultobj = 0;
6481 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6482 : gpgme_pubkey_algo_t arg2 ;
6483 0 : void *argp1 = 0 ;
6484 0 : int res1 = 0 ;
6485 : int val2 ;
6486 0 : int ecode2 = 0 ;
6487 0 : PyObject * obj0 = 0 ;
6488 0 : PyObject * obj1 = 0 ;
6489 :
6490 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
6491 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6492 0 : if (!SWIG_IsOK(res1)) {
6493 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6494 : }
6495 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6496 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
6497 0 : if (!SWIG_IsOK(ecode2)) {
6498 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
6499 : }
6500 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
6501 : {
6502 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6503 0 : if (arg1) (arg1)->pubkey_algo = arg2;
6504 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6505 : }
6506 0 : resultobj = SWIG_Py_Void();
6507 0 : return resultobj;
6508 : fail:
6509 : return NULL;
6510 : }
6511 :
6512 :
6513 108 : SWIGINTERN PyObject *_wrap__gpgme_subkey_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6514 108 : PyObject *resultobj = 0;
6515 108 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6516 108 : void *argp1 = 0 ;
6517 108 : int res1 = 0 ;
6518 108 : PyObject * obj0 = 0 ;
6519 : gpgme_pubkey_algo_t result;
6520 :
6521 108 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_pubkey_algo_get",&obj0)) SWIG_fail;
6522 108 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6523 108 : if (!SWIG_IsOK(res1)) {
6524 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6525 : }
6526 108 : arg1 = (struct _gpgme_subkey *)(argp1);
6527 : {
6528 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6529 108 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
6530 108 : SWIG_PYTHON_THREAD_END_ALLOW;
6531 : }
6532 216 : resultobj = SWIG_From_int((int)(result));
6533 108 : return resultobj;
6534 : fail:
6535 : return NULL;
6536 : }
6537 :
6538 :
6539 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6540 0 : PyObject *resultobj = 0;
6541 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6542 : unsigned int arg2 ;
6543 0 : void *argp1 = 0 ;
6544 0 : int res1 = 0 ;
6545 : unsigned int val2 ;
6546 0 : int ecode2 = 0 ;
6547 0 : PyObject * obj0 = 0 ;
6548 0 : PyObject * obj1 = 0 ;
6549 :
6550 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_length_set",&obj0,&obj1)) SWIG_fail;
6551 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6552 0 : if (!SWIG_IsOK(res1)) {
6553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6554 : }
6555 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6556 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
6557 0 : if (!SWIG_IsOK(ecode2)) {
6558 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_length_set" "', argument " "2"" of type '" "unsigned int""'");
6559 : }
6560 0 : arg2 = (unsigned int)(val2);
6561 : {
6562 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6563 0 : if (arg1) (arg1)->length = arg2;
6564 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6565 : }
6566 0 : resultobj = SWIG_Py_Void();
6567 0 : return resultobj;
6568 : fail:
6569 : return NULL;
6570 : }
6571 :
6572 :
6573 106 : SWIGINTERN PyObject *_wrap__gpgme_subkey_length_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6574 106 : PyObject *resultobj = 0;
6575 106 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6576 106 : void *argp1 = 0 ;
6577 106 : int res1 = 0 ;
6578 106 : PyObject * obj0 = 0 ;
6579 : unsigned int result;
6580 :
6581 106 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_length_get",&obj0)) SWIG_fail;
6582 106 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6583 106 : if (!SWIG_IsOK(res1)) {
6584 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_length_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6585 : }
6586 106 : arg1 = (struct _gpgme_subkey *)(argp1);
6587 : {
6588 106 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6589 106 : result = (unsigned int) ((arg1)->length);
6590 106 : SWIG_PYTHON_THREAD_END_ALLOW;
6591 : }
6592 106 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
6593 106 : return resultobj;
6594 : fail:
6595 : return NULL;
6596 : }
6597 :
6598 :
6599 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6600 0 : PyObject *resultobj = 0;
6601 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6602 0 : char *arg2 = (char *) 0 ;
6603 0 : void *argp1 = 0 ;
6604 0 : int res1 = 0 ;
6605 : int res2 ;
6606 0 : char *buf2 = 0 ;
6607 0 : int alloc2 = 0 ;
6608 0 : PyObject * obj0 = 0 ;
6609 0 : PyObject * obj1 = 0 ;
6610 :
6611 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_keyid_set",&obj0,&obj1)) SWIG_fail;
6612 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6613 0 : if (!SWIG_IsOK(res1)) {
6614 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6615 : }
6616 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6617 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6618 0 : if (!SWIG_IsOK(res2)) {
6619 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keyid_set" "', argument " "2"" of type '" "char *""'");
6620 : }
6621 0 : arg2 = (char *)(buf2);
6622 : {
6623 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6624 0 : if (arg1->keyid) free((char*)arg1->keyid);
6625 0 : if (arg2) {
6626 0 : size_t size = strlen((const char *)(arg2)) + 1;
6627 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6628 : } else {
6629 0 : arg1->keyid = 0;
6630 : }
6631 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6632 : }
6633 0 : resultobj = SWIG_Py_Void();
6634 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6635 : return resultobj;
6636 : fail:
6637 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6638 : return NULL;
6639 : }
6640 :
6641 :
6642 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6643 104 : PyObject *resultobj = 0;
6644 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6645 104 : void *argp1 = 0 ;
6646 104 : int res1 = 0 ;
6647 104 : PyObject * obj0 = 0 ;
6648 104 : char *result = 0 ;
6649 :
6650 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keyid_get",&obj0)) SWIG_fail;
6651 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6652 104 : if (!SWIG_IsOK(res1)) {
6653 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6654 : }
6655 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6656 : {
6657 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6658 104 : result = (char *) ((arg1)->keyid);
6659 104 : SWIG_PYTHON_THREAD_END_ALLOW;
6660 : }
6661 104 : resultobj = SWIG_FromCharPtr((const char *)result);
6662 104 : return resultobj;
6663 : fail:
6664 : return NULL;
6665 : }
6666 :
6667 :
6668 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6669 0 : PyObject *resultobj = 0;
6670 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6671 : char *arg2 ;
6672 0 : void *argp1 = 0 ;
6673 0 : int res1 = 0 ;
6674 : char temp2[16+1] ;
6675 : int res2 ;
6676 0 : PyObject * obj0 = 0 ;
6677 0 : PyObject * obj1 = 0 ;
6678 :
6679 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey__keyid_set",&obj0,&obj1)) SWIG_fail;
6680 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6681 0 : if (!SWIG_IsOK(res1)) {
6682 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6683 : }
6684 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6685 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
6686 0 : if (!SWIG_IsOK(res2)) {
6687 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
6688 : }
6689 0 : arg2 = (char *)(temp2);
6690 : {
6691 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6692 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
6693 : else memset(arg1->_keyid,0,16+1*sizeof(char));
6694 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6695 : }
6696 0 : resultobj = SWIG_Py_Void();
6697 0 : return resultobj;
6698 : fail:
6699 : return NULL;
6700 : }
6701 :
6702 :
6703 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6704 0 : PyObject *resultobj = 0;
6705 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6706 0 : void *argp1 = 0 ;
6707 0 : int res1 = 0 ;
6708 0 : PyObject * obj0 = 0 ;
6709 0 : char *result = 0 ;
6710 :
6711 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey__keyid_get",&obj0)) SWIG_fail;
6712 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6713 0 : if (!SWIG_IsOK(res1)) {
6714 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey__keyid_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6715 : }
6716 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6717 : {
6718 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6719 0 : result = (char *)(char *) ((arg1)->_keyid);
6720 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6721 : }
6722 : {
6723 0 : size_t size = SWIG_strnlen(result, 16+1);
6724 :
6725 :
6726 :
6727 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
6728 : }
6729 0 : return resultobj;
6730 : fail:
6731 : return NULL;
6732 : }
6733 :
6734 :
6735 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6736 0 : PyObject *resultobj = 0;
6737 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6738 0 : char *arg2 = (char *) 0 ;
6739 0 : void *argp1 = 0 ;
6740 0 : int res1 = 0 ;
6741 : int res2 ;
6742 0 : char *buf2 = 0 ;
6743 0 : int alloc2 = 0 ;
6744 0 : PyObject * obj0 = 0 ;
6745 0 : PyObject * obj1 = 0 ;
6746 :
6747 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_fpr_set",&obj0,&obj1)) SWIG_fail;
6748 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6749 0 : if (!SWIG_IsOK(res1)) {
6750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6751 : }
6752 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6753 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6754 0 : if (!SWIG_IsOK(res2)) {
6755 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_fpr_set" "', argument " "2"" of type '" "char *""'");
6756 : }
6757 0 : arg2 = (char *)(buf2);
6758 : {
6759 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6760 0 : if (arg1->fpr) free((char*)arg1->fpr);
6761 0 : if (arg2) {
6762 0 : size_t size = strlen((const char *)(arg2)) + 1;
6763 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6764 : } else {
6765 0 : arg1->fpr = 0;
6766 : }
6767 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6768 : }
6769 0 : resultobj = SWIG_Py_Void();
6770 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6771 : return resultobj;
6772 : fail:
6773 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6774 : return NULL;
6775 : }
6776 :
6777 :
6778 135 : SWIGINTERN PyObject *_wrap__gpgme_subkey_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 135 : PyObject *resultobj = 0;
6780 135 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6781 135 : void *argp1 = 0 ;
6782 135 : int res1 = 0 ;
6783 135 : PyObject * obj0 = 0 ;
6784 135 : char *result = 0 ;
6785 :
6786 135 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_fpr_get",&obj0)) SWIG_fail;
6787 135 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6788 135 : if (!SWIG_IsOK(res1)) {
6789 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_fpr_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6790 : }
6791 135 : arg1 = (struct _gpgme_subkey *)(argp1);
6792 : {
6793 135 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6794 135 : result = (char *) ((arg1)->fpr);
6795 135 : SWIG_PYTHON_THREAD_END_ALLOW;
6796 : }
6797 135 : resultobj = SWIG_FromCharPtr((const char *)result);
6798 135 : return resultobj;
6799 : fail:
6800 : return NULL;
6801 : }
6802 :
6803 :
6804 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6805 0 : PyObject *resultobj = 0;
6806 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6807 : long arg2 ;
6808 0 : void *argp1 = 0 ;
6809 0 : int res1 = 0 ;
6810 : long val2 ;
6811 0 : int ecode2 = 0 ;
6812 0 : PyObject * obj0 = 0 ;
6813 0 : PyObject * obj1 = 0 ;
6814 :
6815 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_timestamp_set",&obj0,&obj1)) SWIG_fail;
6816 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6817 0 : if (!SWIG_IsOK(res1)) {
6818 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6819 : }
6820 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6821 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
6822 0 : if (!SWIG_IsOK(ecode2)) {
6823 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_timestamp_set" "', argument " "2"" of type '" "long""'");
6824 : }
6825 0 : arg2 = (long)(val2);
6826 : {
6827 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6828 0 : if (arg1) (arg1)->timestamp = arg2;
6829 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6830 : }
6831 0 : resultobj = SWIG_Py_Void();
6832 0 : return resultobj;
6833 : fail:
6834 : return NULL;
6835 : }
6836 :
6837 :
6838 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6839 0 : PyObject *resultobj = 0;
6840 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6841 0 : void *argp1 = 0 ;
6842 0 : int res1 = 0 ;
6843 0 : PyObject * obj0 = 0 ;
6844 : long result;
6845 :
6846 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_timestamp_get",&obj0)) SWIG_fail;
6847 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6848 0 : if (!SWIG_IsOK(res1)) {
6849 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6850 : }
6851 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6852 : {
6853 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6854 0 : result = (long) ((arg1)->timestamp);
6855 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6856 : }
6857 0 : resultobj = SWIG_From_long((long)(result));
6858 0 : return resultobj;
6859 : fail:
6860 : return NULL;
6861 : }
6862 :
6863 :
6864 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6865 0 : PyObject *resultobj = 0;
6866 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6867 : long arg2 ;
6868 0 : void *argp1 = 0 ;
6869 0 : int res1 = 0 ;
6870 : long val2 ;
6871 0 : int ecode2 = 0 ;
6872 0 : PyObject * obj0 = 0 ;
6873 0 : PyObject * obj1 = 0 ;
6874 :
6875 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_expires_set",&obj0,&obj1)) SWIG_fail;
6876 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6877 0 : if (!SWIG_IsOK(res1)) {
6878 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6879 : }
6880 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6881 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
6882 0 : if (!SWIG_IsOK(ecode2)) {
6883 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_subkey_expires_set" "', argument " "2"" of type '" "long""'");
6884 : }
6885 0 : arg2 = (long)(val2);
6886 : {
6887 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6888 0 : if (arg1) (arg1)->expires = arg2;
6889 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6890 : }
6891 0 : resultobj = SWIG_Py_Void();
6892 0 : return resultobj;
6893 : fail:
6894 : return NULL;
6895 : }
6896 :
6897 :
6898 113 : SWIGINTERN PyObject *_wrap__gpgme_subkey_expires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6899 113 : PyObject *resultobj = 0;
6900 113 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6901 113 : void *argp1 = 0 ;
6902 113 : int res1 = 0 ;
6903 113 : PyObject * obj0 = 0 ;
6904 : long result;
6905 :
6906 113 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_expires_get",&obj0)) SWIG_fail;
6907 113 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6908 113 : if (!SWIG_IsOK(res1)) {
6909 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_expires_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6910 : }
6911 113 : arg1 = (struct _gpgme_subkey *)(argp1);
6912 : {
6913 113 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6914 113 : result = (long) ((arg1)->expires);
6915 113 : SWIG_PYTHON_THREAD_END_ALLOW;
6916 : }
6917 113 : resultobj = SWIG_From_long((long)(result));
6918 113 : return resultobj;
6919 : fail:
6920 : return NULL;
6921 : }
6922 :
6923 :
6924 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6925 0 : PyObject *resultobj = 0;
6926 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6927 0 : char *arg2 = (char *) 0 ;
6928 0 : void *argp1 = 0 ;
6929 0 : int res1 = 0 ;
6930 : int res2 ;
6931 0 : char *buf2 = 0 ;
6932 0 : int alloc2 = 0 ;
6933 0 : PyObject * obj0 = 0 ;
6934 0 : PyObject * obj1 = 0 ;
6935 :
6936 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_card_number_set",&obj0,&obj1)) SWIG_fail;
6937 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6938 0 : if (!SWIG_IsOK(res1)) {
6939 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6940 : }
6941 0 : arg1 = (struct _gpgme_subkey *)(argp1);
6942 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
6943 0 : if (!SWIG_IsOK(res2)) {
6944 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_card_number_set" "', argument " "2"" of type '" "char *""'");
6945 : }
6946 0 : arg2 = (char *)(buf2);
6947 : {
6948 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6949 0 : if (arg1->card_number) free((char*)arg1->card_number);
6950 0 : if (arg2) {
6951 0 : size_t size = strlen((const char *)(arg2)) + 1;
6952 0 : arg1->card_number = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
6953 : } else {
6954 0 : arg1->card_number = 0;
6955 : }
6956 0 : SWIG_PYTHON_THREAD_END_ALLOW;
6957 : }
6958 0 : resultobj = SWIG_Py_Void();
6959 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6960 : return resultobj;
6961 : fail:
6962 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
6963 : return NULL;
6964 : }
6965 :
6966 :
6967 104 : SWIGINTERN PyObject *_wrap__gpgme_subkey_card_number_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6968 104 : PyObject *resultobj = 0;
6969 104 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6970 104 : void *argp1 = 0 ;
6971 104 : int res1 = 0 ;
6972 104 : PyObject * obj0 = 0 ;
6973 104 : char *result = 0 ;
6974 :
6975 104 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_card_number_get",&obj0)) SWIG_fail;
6976 104 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
6977 104 : if (!SWIG_IsOK(res1)) {
6978 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_card_number_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
6979 : }
6980 104 : arg1 = (struct _gpgme_subkey *)(argp1);
6981 : {
6982 104 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
6983 104 : result = (char *) ((arg1)->card_number);
6984 104 : SWIG_PYTHON_THREAD_END_ALLOW;
6985 : }
6986 104 : resultobj = SWIG_FromCharPtr((const char *)result);
6987 104 : return resultobj;
6988 : fail:
6989 : return NULL;
6990 : }
6991 :
6992 :
6993 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6994 0 : PyObject *resultobj = 0;
6995 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
6996 0 : char *arg2 = (char *) 0 ;
6997 0 : void *argp1 = 0 ;
6998 0 : int res1 = 0 ;
6999 : int res2 ;
7000 0 : char *buf2 = 0 ;
7001 0 : int alloc2 = 0 ;
7002 0 : PyObject * obj0 = 0 ;
7003 0 : PyObject * obj1 = 0 ;
7004 :
7005 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_curve_set",&obj0,&obj1)) SWIG_fail;
7006 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7007 0 : if (!SWIG_IsOK(res1)) {
7008 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7009 : }
7010 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7011 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7012 0 : if (!SWIG_IsOK(res2)) {
7013 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_curve_set" "', argument " "2"" of type '" "char *""'");
7014 : }
7015 0 : arg2 = (char *)(buf2);
7016 : {
7017 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7018 0 : if (arg1->curve) free((char*)arg1->curve);
7019 0 : if (arg2) {
7020 0 : size_t size = strlen((const char *)(arg2)) + 1;
7021 0 : arg1->curve = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7022 : } else {
7023 0 : arg1->curve = 0;
7024 : }
7025 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7026 : }
7027 0 : resultobj = SWIG_Py_Void();
7028 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7029 : return resultobj;
7030 : fail:
7031 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7032 : return NULL;
7033 : }
7034 :
7035 :
7036 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_curve_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7037 0 : PyObject *resultobj = 0;
7038 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7039 0 : void *argp1 = 0 ;
7040 0 : int res1 = 0 ;
7041 0 : PyObject * obj0 = 0 ;
7042 0 : char *result = 0 ;
7043 :
7044 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_curve_get",&obj0)) SWIG_fail;
7045 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7046 0 : if (!SWIG_IsOK(res1)) {
7047 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_curve_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7048 : }
7049 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7050 : {
7051 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7052 0 : result = (char *) ((arg1)->curve);
7053 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7054 : }
7055 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7056 0 : return resultobj;
7057 : fail:
7058 : return NULL;
7059 : }
7060 :
7061 :
7062 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7063 0 : PyObject *resultobj = 0;
7064 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7065 0 : char *arg2 = (char *) 0 ;
7066 0 : void *argp1 = 0 ;
7067 0 : int res1 = 0 ;
7068 : int res2 ;
7069 0 : char *buf2 = 0 ;
7070 0 : int alloc2 = 0 ;
7071 0 : PyObject * obj0 = 0 ;
7072 0 : PyObject * obj1 = 0 ;
7073 :
7074 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_subkey_keygrip_set",&obj0,&obj1)) SWIG_fail;
7075 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7076 0 : if (!SWIG_IsOK(res1)) {
7077 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7078 : }
7079 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7080 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7081 0 : if (!SWIG_IsOK(res2)) {
7082 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_subkey_keygrip_set" "', argument " "2"" of type '" "char *""'");
7083 : }
7084 0 : arg2 = (char *)(buf2);
7085 : {
7086 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7087 0 : if (arg1->keygrip) free((char*)arg1->keygrip);
7088 0 : if (arg2) {
7089 0 : size_t size = strlen((const char *)(arg2)) + 1;
7090 0 : arg1->keygrip = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7091 : } else {
7092 0 : arg1->keygrip = 0;
7093 : }
7094 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7095 : }
7096 0 : resultobj = SWIG_Py_Void();
7097 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7098 : return resultobj;
7099 : fail:
7100 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7101 : return NULL;
7102 : }
7103 :
7104 :
7105 0 : SWIGINTERN PyObject *_wrap__gpgme_subkey_keygrip_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7106 0 : PyObject *resultobj = 0;
7107 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7108 0 : void *argp1 = 0 ;
7109 0 : int res1 = 0 ;
7110 0 : PyObject * obj0 = 0 ;
7111 0 : char *result = 0 ;
7112 :
7113 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_subkey_keygrip_get",&obj0)) SWIG_fail;
7114 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
7115 0 : if (!SWIG_IsOK(res1)) {
7116 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_subkey_keygrip_get" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7117 : }
7118 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7119 : {
7120 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7121 0 : result = (char *) ((arg1)->keygrip);
7122 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7123 : }
7124 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7125 0 : return resultobj;
7126 : fail:
7127 : return NULL;
7128 : }
7129 :
7130 :
7131 0 : SWIGINTERN PyObject *_wrap_new__gpgme_subkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7132 0 : PyObject *resultobj = 0;
7133 0 : struct _gpgme_subkey *result = 0 ;
7134 :
7135 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_subkey")) SWIG_fail;
7136 : {
7137 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7138 0 : result = (struct _gpgme_subkey *)calloc(1, sizeof(struct _gpgme_subkey));
7139 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7140 : }
7141 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_NEW | 0 );
7142 0 : return resultobj;
7143 : fail:
7144 : return NULL;
7145 : }
7146 :
7147 :
7148 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_subkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7149 0 : PyObject *resultobj = 0;
7150 0 : struct _gpgme_subkey *arg1 = (struct _gpgme_subkey *) 0 ;
7151 0 : void *argp1 = 0 ;
7152 0 : int res1 = 0 ;
7153 0 : PyObject * obj0 = 0 ;
7154 :
7155 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_subkey",&obj0)) SWIG_fail;
7156 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
7157 0 : if (!SWIG_IsOK(res1)) {
7158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_subkey" "', argument " "1"" of type '" "struct _gpgme_subkey *""'");
7159 : }
7160 0 : arg1 = (struct _gpgme_subkey *)(argp1);
7161 : {
7162 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7163 0 : free((char *) arg1);
7164 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7165 : }
7166 0 : resultobj = SWIG_Py_Void();
7167 0 : return resultobj;
7168 : fail:
7169 : return NULL;
7170 : }
7171 :
7172 :
7173 27 : SWIGINTERN PyObject *_gpgme_subkey_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7174 : PyObject *obj;
7175 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
7176 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_subkey, SWIG_NewClientData(obj));
7177 27 : return SWIG_Py_Void();
7178 : }
7179 :
7180 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7181 0 : PyObject *resultobj = 0;
7182 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7183 : unsigned int arg2 ;
7184 0 : void *argp1 = 0 ;
7185 0 : int res1 = 0 ;
7186 : unsigned int val2 ;
7187 0 : int ecode2 = 0 ;
7188 0 : PyObject * obj0 = 0 ;
7189 0 : PyObject * obj1 = 0 ;
7190 :
7191 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_revoked_set",&obj0,&obj1)) SWIG_fail;
7192 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7193 0 : if (!SWIG_IsOK(res1)) {
7194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7195 : }
7196 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7197 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7198 0 : if (!SWIG_IsOK(ecode2)) {
7199 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
7200 : }
7201 0 : arg2 = (unsigned int)(val2);
7202 : {
7203 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7204 0 : if (arg1) (arg1)->revoked = arg2;
7205 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7206 : }
7207 0 : resultobj = SWIG_Py_Void();
7208 0 : return resultobj;
7209 : fail:
7210 : return NULL;
7211 : }
7212 :
7213 :
7214 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7215 0 : PyObject *resultobj = 0;
7216 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7217 0 : void *argp1 = 0 ;
7218 0 : int res1 = 0 ;
7219 0 : PyObject * obj0 = 0 ;
7220 : unsigned int result;
7221 :
7222 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_revoked_get",&obj0)) SWIG_fail;
7223 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7224 0 : if (!SWIG_IsOK(res1)) {
7225 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7226 : }
7227 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7228 : {
7229 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7230 0 : result = (unsigned int) ((arg1)->revoked);
7231 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7232 : }
7233 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7234 0 : return resultobj;
7235 : fail:
7236 : return NULL;
7237 : }
7238 :
7239 :
7240 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7241 0 : PyObject *resultobj = 0;
7242 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7243 : unsigned int arg2 ;
7244 0 : void *argp1 = 0 ;
7245 0 : int res1 = 0 ;
7246 : unsigned int val2 ;
7247 0 : int ecode2 = 0 ;
7248 0 : PyObject * obj0 = 0 ;
7249 0 : PyObject * obj1 = 0 ;
7250 :
7251 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_expired_set",&obj0,&obj1)) SWIG_fail;
7252 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7253 0 : if (!SWIG_IsOK(res1)) {
7254 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7255 : }
7256 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7257 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7258 0 : if (!SWIG_IsOK(ecode2)) {
7259 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expired_set" "', argument " "2"" of type '" "unsigned int""'");
7260 : }
7261 0 : arg2 = (unsigned int)(val2);
7262 : {
7263 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7264 0 : if (arg1) (arg1)->expired = arg2;
7265 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7266 : }
7267 0 : resultobj = SWIG_Py_Void();
7268 0 : return resultobj;
7269 : fail:
7270 : return NULL;
7271 : }
7272 :
7273 :
7274 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7275 0 : PyObject *resultobj = 0;
7276 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7277 0 : void *argp1 = 0 ;
7278 0 : int res1 = 0 ;
7279 0 : PyObject * obj0 = 0 ;
7280 : unsigned int result;
7281 :
7282 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expired_get",&obj0)) SWIG_fail;
7283 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7284 0 : if (!SWIG_IsOK(res1)) {
7285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expired_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7286 : }
7287 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7288 : {
7289 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7290 0 : result = (unsigned int) ((arg1)->expired);
7291 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7292 : }
7293 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7294 0 : return resultobj;
7295 : fail:
7296 : return NULL;
7297 : }
7298 :
7299 :
7300 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7301 0 : PyObject *resultobj = 0;
7302 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7303 : unsigned int arg2 ;
7304 0 : void *argp1 = 0 ;
7305 0 : int res1 = 0 ;
7306 : unsigned int val2 ;
7307 0 : int ecode2 = 0 ;
7308 0 : PyObject * obj0 = 0 ;
7309 0 : PyObject * obj1 = 0 ;
7310 :
7311 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_invalid_set",&obj0,&obj1)) SWIG_fail;
7312 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7313 0 : if (!SWIG_IsOK(res1)) {
7314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7315 : }
7316 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7317 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7318 0 : if (!SWIG_IsOK(ecode2)) {
7319 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
7320 : }
7321 0 : arg2 = (unsigned int)(val2);
7322 : {
7323 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7324 0 : if (arg1) (arg1)->invalid = arg2;
7325 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7326 : }
7327 0 : resultobj = SWIG_Py_Void();
7328 0 : return resultobj;
7329 : fail:
7330 : return NULL;
7331 : }
7332 :
7333 :
7334 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7335 0 : PyObject *resultobj = 0;
7336 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7337 0 : void *argp1 = 0 ;
7338 0 : int res1 = 0 ;
7339 0 : PyObject * obj0 = 0 ;
7340 : unsigned int result;
7341 :
7342 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_invalid_get",&obj0)) SWIG_fail;
7343 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7344 0 : if (!SWIG_IsOK(res1)) {
7345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7346 : }
7347 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7348 : {
7349 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7350 0 : result = (unsigned int) ((arg1)->invalid);
7351 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7352 : }
7353 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7354 0 : return resultobj;
7355 : fail:
7356 : return NULL;
7357 : }
7358 :
7359 :
7360 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7361 0 : PyObject *resultobj = 0;
7362 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7363 : unsigned int arg2 ;
7364 0 : void *argp1 = 0 ;
7365 0 : int res1 = 0 ;
7366 : unsigned int val2 ;
7367 0 : int ecode2 = 0 ;
7368 0 : PyObject * obj0 = 0 ;
7369 0 : PyObject * obj1 = 0 ;
7370 :
7371 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_exportable_set",&obj0,&obj1)) SWIG_fail;
7372 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7373 0 : if (!SWIG_IsOK(res1)) {
7374 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7375 : }
7376 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7377 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7378 0 : if (!SWIG_IsOK(ecode2)) {
7379 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_exportable_set" "', argument " "2"" of type '" "unsigned int""'");
7380 : }
7381 0 : arg2 = (unsigned int)(val2);
7382 : {
7383 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7384 0 : if (arg1) (arg1)->exportable = arg2;
7385 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7386 : }
7387 0 : resultobj = SWIG_Py_Void();
7388 0 : return resultobj;
7389 : fail:
7390 : return NULL;
7391 : }
7392 :
7393 :
7394 27 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_exportable_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7395 27 : PyObject *resultobj = 0;
7396 27 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7397 27 : void *argp1 = 0 ;
7398 27 : int res1 = 0 ;
7399 27 : PyObject * obj0 = 0 ;
7400 : unsigned int result;
7401 :
7402 27 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_exportable_get",&obj0)) SWIG_fail;
7403 27 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7404 27 : if (!SWIG_IsOK(res1)) {
7405 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_exportable_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7406 : }
7407 27 : arg1 = (struct _gpgme_key_sig *)(argp1);
7408 : {
7409 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7410 27 : result = (unsigned int) ((arg1)->exportable);
7411 27 : SWIG_PYTHON_THREAD_END_ALLOW;
7412 : }
7413 27 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7414 27 : return resultobj;
7415 : fail:
7416 : return NULL;
7417 : }
7418 :
7419 :
7420 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7421 0 : PyObject *resultobj = 0;
7422 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7423 : unsigned int arg2 ;
7424 0 : void *argp1 = 0 ;
7425 0 : int res1 = 0 ;
7426 : unsigned int val2 ;
7427 0 : int ecode2 = 0 ;
7428 0 : PyObject * obj0 = 0 ;
7429 0 : PyObject * obj1 = 0 ;
7430 :
7431 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__unused_set",&obj0,&obj1)) SWIG_fail;
7432 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7433 0 : if (!SWIG_IsOK(res1)) {
7434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7435 : }
7436 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7437 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
7438 0 : if (!SWIG_IsOK(ecode2)) {
7439 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig__unused_set" "', argument " "2"" of type '" "unsigned int""'");
7440 : }
7441 0 : arg2 = (unsigned int)(val2);
7442 : {
7443 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7444 0 : if (arg1) (arg1)->_unused = arg2;
7445 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7446 : }
7447 0 : resultobj = SWIG_Py_Void();
7448 0 : return resultobj;
7449 : fail:
7450 : return NULL;
7451 : }
7452 :
7453 :
7454 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7455 0 : PyObject *resultobj = 0;
7456 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7457 0 : void *argp1 = 0 ;
7458 0 : int res1 = 0 ;
7459 0 : PyObject * obj0 = 0 ;
7460 : unsigned int result;
7461 :
7462 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__unused_get",&obj0)) SWIG_fail;
7463 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7464 0 : if (!SWIG_IsOK(res1)) {
7465 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__unused_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7466 : }
7467 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7468 : {
7469 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7470 0 : result = (unsigned int) ((arg1)->_unused);
7471 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7472 : }
7473 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
7474 0 : return resultobj;
7475 : fail:
7476 : return NULL;
7477 : }
7478 :
7479 :
7480 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7481 0 : PyObject *resultobj = 0;
7482 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7483 : gpgme_pubkey_algo_t arg2 ;
7484 0 : void *argp1 = 0 ;
7485 0 : int res1 = 0 ;
7486 : int val2 ;
7487 0 : int ecode2 = 0 ;
7488 0 : PyObject * obj0 = 0 ;
7489 0 : PyObject * obj1 = 0 ;
7490 :
7491 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
7492 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7493 0 : if (!SWIG_IsOK(res1)) {
7494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7495 : }
7496 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7497 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
7498 0 : if (!SWIG_IsOK(ecode2)) {
7499 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
7500 : }
7501 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
7502 : {
7503 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7504 0 : if (arg1) (arg1)->pubkey_algo = arg2;
7505 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7506 : }
7507 0 : resultobj = SWIG_Py_Void();
7508 0 : return resultobj;
7509 : fail:
7510 : return NULL;
7511 : }
7512 :
7513 :
7514 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7515 0 : PyObject *resultobj = 0;
7516 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7517 0 : void *argp1 = 0 ;
7518 0 : int res1 = 0 ;
7519 0 : PyObject * obj0 = 0 ;
7520 : gpgme_pubkey_algo_t result;
7521 :
7522 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_pubkey_algo_get",&obj0)) SWIG_fail;
7523 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7524 0 : if (!SWIG_IsOK(res1)) {
7525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7526 : }
7527 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7528 : {
7529 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7530 0 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
7531 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7532 : }
7533 0 : resultobj = SWIG_From_int((int)(result));
7534 0 : return resultobj;
7535 : fail:
7536 : return NULL;
7537 : }
7538 :
7539 :
7540 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7541 0 : PyObject *resultobj = 0;
7542 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7543 0 : char *arg2 = (char *) 0 ;
7544 0 : void *argp1 = 0 ;
7545 0 : int res1 = 0 ;
7546 : int res2 ;
7547 0 : char *buf2 = 0 ;
7548 0 : int alloc2 = 0 ;
7549 0 : PyObject * obj0 = 0 ;
7550 0 : PyObject * obj1 = 0 ;
7551 :
7552 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_keyid_set",&obj0,&obj1)) SWIG_fail;
7553 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7554 0 : if (!SWIG_IsOK(res1)) {
7555 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7556 : }
7557 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7558 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7559 0 : if (!SWIG_IsOK(res2)) {
7560 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_keyid_set" "', argument " "2"" of type '" "char *""'");
7561 : }
7562 0 : arg2 = (char *)(buf2);
7563 : {
7564 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7565 0 : if (arg1->keyid) free((char*)arg1->keyid);
7566 0 : if (arg2) {
7567 0 : size_t size = strlen((const char *)(arg2)) + 1;
7568 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7569 : } else {
7570 0 : arg1->keyid = 0;
7571 : }
7572 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7573 : }
7574 0 : resultobj = SWIG_Py_Void();
7575 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7576 : return resultobj;
7577 : fail:
7578 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7579 : return NULL;
7580 : }
7581 :
7582 :
7583 30 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7584 30 : PyObject *resultobj = 0;
7585 30 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7586 30 : void *argp1 = 0 ;
7587 30 : int res1 = 0 ;
7588 30 : PyObject * obj0 = 0 ;
7589 30 : char *result = 0 ;
7590 :
7591 30 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_keyid_get",&obj0)) SWIG_fail;
7592 30 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7593 30 : if (!SWIG_IsOK(res1)) {
7594 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7595 : }
7596 30 : arg1 = (struct _gpgme_key_sig *)(argp1);
7597 : {
7598 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7599 30 : result = (char *) ((arg1)->keyid);
7600 30 : SWIG_PYTHON_THREAD_END_ALLOW;
7601 : }
7602 30 : resultobj = SWIG_FromCharPtr((const char *)result);
7603 30 : return resultobj;
7604 : fail:
7605 : return NULL;
7606 : }
7607 :
7608 :
7609 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7610 0 : PyObject *resultobj = 0;
7611 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7612 : char *arg2 ;
7613 0 : void *argp1 = 0 ;
7614 0 : int res1 = 0 ;
7615 : char temp2[16+1] ;
7616 : int res2 ;
7617 0 : PyObject * obj0 = 0 ;
7618 0 : PyObject * obj1 = 0 ;
7619 :
7620 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__keyid_set",&obj0,&obj1)) SWIG_fail;
7621 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7622 0 : if (!SWIG_IsOK(res1)) {
7623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7624 : }
7625 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7626 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
7627 0 : if (!SWIG_IsOK(res2)) {
7628 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
7629 : }
7630 0 : arg2 = (char *)(temp2);
7631 : {
7632 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7633 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
7634 : else memset(arg1->_keyid,0,16+1*sizeof(char));
7635 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7636 : }
7637 0 : resultobj = SWIG_Py_Void();
7638 0 : return resultobj;
7639 : fail:
7640 : return NULL;
7641 : }
7642 :
7643 :
7644 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7645 0 : PyObject *resultobj = 0;
7646 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7647 0 : void *argp1 = 0 ;
7648 0 : int res1 = 0 ;
7649 0 : PyObject * obj0 = 0 ;
7650 0 : char *result = 0 ;
7651 :
7652 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__keyid_get",&obj0)) SWIG_fail;
7653 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7654 0 : if (!SWIG_IsOK(res1)) {
7655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__keyid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7656 : }
7657 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7658 : {
7659 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7660 0 : result = (char *)(char *) ((arg1)->_keyid);
7661 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7662 : }
7663 : {
7664 0 : size_t size = SWIG_strnlen(result, 16+1);
7665 :
7666 :
7667 :
7668 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
7669 : }
7670 0 : return resultobj;
7671 : fail:
7672 : return NULL;
7673 : }
7674 :
7675 :
7676 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7677 0 : PyObject *resultobj = 0;
7678 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7679 : long arg2 ;
7680 0 : void *argp1 = 0 ;
7681 0 : int res1 = 0 ;
7682 : long val2 ;
7683 0 : int ecode2 = 0 ;
7684 0 : PyObject * obj0 = 0 ;
7685 0 : PyObject * obj1 = 0 ;
7686 :
7687 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_timestamp_set",&obj0,&obj1)) SWIG_fail;
7688 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7689 0 : if (!SWIG_IsOK(res1)) {
7690 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7691 : }
7692 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7693 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7694 0 : if (!SWIG_IsOK(ecode2)) {
7695 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_timestamp_set" "', argument " "2"" of type '" "long""'");
7696 : }
7697 0 : arg2 = (long)(val2);
7698 : {
7699 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7700 0 : if (arg1) (arg1)->timestamp = arg2;
7701 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7702 : }
7703 0 : resultobj = SWIG_Py_Void();
7704 0 : return resultobj;
7705 : fail:
7706 : return NULL;
7707 : }
7708 :
7709 :
7710 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7711 0 : PyObject *resultobj = 0;
7712 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7713 0 : void *argp1 = 0 ;
7714 0 : int res1 = 0 ;
7715 0 : PyObject * obj0 = 0 ;
7716 : long result;
7717 :
7718 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_timestamp_get",&obj0)) SWIG_fail;
7719 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7720 0 : if (!SWIG_IsOK(res1)) {
7721 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7722 : }
7723 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7724 : {
7725 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7726 0 : result = (long) ((arg1)->timestamp);
7727 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7728 : }
7729 0 : resultobj = SWIG_From_long((long)(result));
7730 0 : return resultobj;
7731 : fail:
7732 : return NULL;
7733 : }
7734 :
7735 :
7736 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7737 0 : PyObject *resultobj = 0;
7738 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7739 : long arg2 ;
7740 0 : void *argp1 = 0 ;
7741 0 : int res1 = 0 ;
7742 : long val2 ;
7743 0 : int ecode2 = 0 ;
7744 0 : PyObject * obj0 = 0 ;
7745 0 : PyObject * obj1 = 0 ;
7746 :
7747 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_expires_set",&obj0,&obj1)) SWIG_fail;
7748 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7749 0 : if (!SWIG_IsOK(res1)) {
7750 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7751 : }
7752 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7753 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
7754 0 : if (!SWIG_IsOK(ecode2)) {
7755 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_expires_set" "', argument " "2"" of type '" "long""'");
7756 : }
7757 0 : arg2 = (long)(val2);
7758 : {
7759 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7760 0 : if (arg1) (arg1)->expires = arg2;
7761 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7762 : }
7763 0 : resultobj = SWIG_Py_Void();
7764 0 : return resultobj;
7765 : fail:
7766 : return NULL;
7767 : }
7768 :
7769 :
7770 27 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_expires_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7771 27 : PyObject *resultobj = 0;
7772 27 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7773 27 : void *argp1 = 0 ;
7774 27 : int res1 = 0 ;
7775 27 : PyObject * obj0 = 0 ;
7776 : long result;
7777 :
7778 27 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_expires_get",&obj0)) SWIG_fail;
7779 27 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7780 27 : if (!SWIG_IsOK(res1)) {
7781 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_expires_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7782 : }
7783 27 : arg1 = (struct _gpgme_key_sig *)(argp1);
7784 : {
7785 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7786 27 : result = (long) ((arg1)->expires);
7787 27 : SWIG_PYTHON_THREAD_END_ALLOW;
7788 : }
7789 27 : resultobj = SWIG_From_long((long)(result));
7790 27 : return resultobj;
7791 : fail:
7792 : return NULL;
7793 : }
7794 :
7795 :
7796 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7797 0 : PyObject *resultobj = 0;
7798 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7799 : gpgme_error_t arg2 ;
7800 0 : void *argp1 = 0 ;
7801 0 : int res1 = 0 ;
7802 0 : PyObject * obj0 = 0 ;
7803 0 : PyObject * obj1 = 0 ;
7804 :
7805 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_status_set",&obj0,&obj1)) SWIG_fail;
7806 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7807 0 : if (!SWIG_IsOK(res1)) {
7808 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7809 : }
7810 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7811 : {
7812 0 : if (PyLong_Check(obj1))
7813 0 : arg2 = PyLong_AsLong(obj1);
7814 :
7815 0 : else if (PyInt_Check(obj1))
7816 0 : arg2 = PyInt_AsLong(obj1);
7817 :
7818 : else
7819 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
7820 : }
7821 : {
7822 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7823 0 : if (arg1) (arg1)->status = arg2;
7824 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7825 : }
7826 0 : resultobj = SWIG_Py_Void();
7827 0 : return resultobj;
7828 : fail:
7829 : return NULL;
7830 : }
7831 :
7832 :
7833 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7834 0 : PyObject *resultobj = 0;
7835 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7836 0 : void *argp1 = 0 ;
7837 0 : int res1 = 0 ;
7838 0 : PyObject * obj0 = 0 ;
7839 : gpgme_error_t result;
7840 :
7841 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_status_get",&obj0)) SWIG_fail;
7842 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7843 0 : if (!SWIG_IsOK(res1)) {
7844 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_status_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7845 : }
7846 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7847 : {
7848 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7849 0 : result = ((arg1)->status);
7850 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7851 : }
7852 : {
7853 0 : resultobj = PyLong_FromLong(result);
7854 : }
7855 0 : return resultobj;
7856 : fail:
7857 : return NULL;
7858 : }
7859 :
7860 :
7861 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7862 0 : PyObject *resultobj = 0;
7863 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7864 0 : char *arg2 = (char *) 0 ;
7865 0 : void *argp1 = 0 ;
7866 0 : int res1 = 0 ;
7867 : int res2 ;
7868 0 : char *buf2 = 0 ;
7869 0 : int alloc2 = 0 ;
7870 0 : PyObject * obj0 = 0 ;
7871 0 : PyObject * obj1 = 0 ;
7872 :
7873 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_uid_set",&obj0,&obj1)) SWIG_fail;
7874 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7875 0 : if (!SWIG_IsOK(res1)) {
7876 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7877 : }
7878 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7879 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7880 0 : if (!SWIG_IsOK(res2)) {
7881 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_uid_set" "', argument " "2"" of type '" "char *""'");
7882 : }
7883 0 : arg2 = (char *)(buf2);
7884 : {
7885 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7886 0 : if (arg1->uid) free((char*)arg1->uid);
7887 0 : if (arg2) {
7888 0 : size_t size = strlen((const char *)(arg2)) + 1;
7889 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7890 : } else {
7891 0 : arg1->uid = 0;
7892 : }
7893 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7894 : }
7895 0 : resultobj = SWIG_Py_Void();
7896 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7897 : return resultobj;
7898 : fail:
7899 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7900 : return NULL;
7901 : }
7902 :
7903 :
7904 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7905 0 : PyObject *resultobj = 0;
7906 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7907 0 : void *argp1 = 0 ;
7908 0 : int res1 = 0 ;
7909 0 : PyObject * obj0 = 0 ;
7910 0 : char *result = 0 ;
7911 :
7912 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_uid_get",&obj0)) SWIG_fail;
7913 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7914 0 : if (!SWIG_IsOK(res1)) {
7915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_uid_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7916 : }
7917 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7918 : {
7919 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7920 0 : result = (char *) ((arg1)->uid);
7921 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7922 : }
7923 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7924 0 : return resultobj;
7925 : fail:
7926 : return NULL;
7927 : }
7928 :
7929 :
7930 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7931 0 : PyObject *resultobj = 0;
7932 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7933 0 : char *arg2 = (char *) 0 ;
7934 0 : void *argp1 = 0 ;
7935 0 : int res1 = 0 ;
7936 : int res2 ;
7937 0 : char *buf2 = 0 ;
7938 0 : int alloc2 = 0 ;
7939 0 : PyObject * obj0 = 0 ;
7940 0 : PyObject * obj1 = 0 ;
7941 :
7942 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_name_set",&obj0,&obj1)) SWIG_fail;
7943 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7944 0 : if (!SWIG_IsOK(res1)) {
7945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7946 : }
7947 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7948 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
7949 0 : if (!SWIG_IsOK(res2)) {
7950 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_name_set" "', argument " "2"" of type '" "char *""'");
7951 : }
7952 0 : arg2 = (char *)(buf2);
7953 : {
7954 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7955 0 : if (arg1->name) free((char*)arg1->name);
7956 0 : if (arg2) {
7957 0 : size_t size = strlen((const char *)(arg2)) + 1;
7958 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
7959 : } else {
7960 0 : arg1->name = 0;
7961 : }
7962 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7963 : }
7964 0 : resultobj = SWIG_Py_Void();
7965 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7966 : return resultobj;
7967 : fail:
7968 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
7969 : return NULL;
7970 : }
7971 :
7972 :
7973 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7974 0 : PyObject *resultobj = 0;
7975 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
7976 0 : void *argp1 = 0 ;
7977 0 : int res1 = 0 ;
7978 0 : PyObject * obj0 = 0 ;
7979 0 : char *result = 0 ;
7980 :
7981 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_name_get",&obj0)) SWIG_fail;
7982 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
7983 0 : if (!SWIG_IsOK(res1)) {
7984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_name_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
7985 : }
7986 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
7987 : {
7988 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
7989 0 : result = (char *) ((arg1)->name);
7990 0 : SWIG_PYTHON_THREAD_END_ALLOW;
7991 : }
7992 0 : resultobj = SWIG_FromCharPtr((const char *)result);
7993 0 : return resultobj;
7994 : fail:
7995 : return NULL;
7996 : }
7997 :
7998 :
7999 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8000 0 : PyObject *resultobj = 0;
8001 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8002 0 : char *arg2 = (char *) 0 ;
8003 0 : void *argp1 = 0 ;
8004 0 : int res1 = 0 ;
8005 : int res2 ;
8006 0 : char *buf2 = 0 ;
8007 0 : int alloc2 = 0 ;
8008 0 : PyObject * obj0 = 0 ;
8009 0 : PyObject * obj1 = 0 ;
8010 :
8011 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_email_set",&obj0,&obj1)) SWIG_fail;
8012 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8013 0 : if (!SWIG_IsOK(res1)) {
8014 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8015 : }
8016 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8017 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8018 0 : if (!SWIG_IsOK(res2)) {
8019 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_email_set" "', argument " "2"" of type '" "char *""'");
8020 : }
8021 0 : arg2 = (char *)(buf2);
8022 : {
8023 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8024 0 : if (arg1->email) free((char*)arg1->email);
8025 0 : if (arg2) {
8026 0 : size_t size = strlen((const char *)(arg2)) + 1;
8027 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8028 : } else {
8029 0 : arg1->email = 0;
8030 : }
8031 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8032 : }
8033 0 : resultobj = SWIG_Py_Void();
8034 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8035 : return resultobj;
8036 : fail:
8037 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8038 : return NULL;
8039 : }
8040 :
8041 :
8042 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_email_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8043 0 : PyObject *resultobj = 0;
8044 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8045 0 : void *argp1 = 0 ;
8046 0 : int res1 = 0 ;
8047 0 : PyObject * obj0 = 0 ;
8048 0 : char *result = 0 ;
8049 :
8050 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_email_get",&obj0)) SWIG_fail;
8051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8052 0 : if (!SWIG_IsOK(res1)) {
8053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_email_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8054 : }
8055 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8056 : {
8057 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8058 0 : result = (char *) ((arg1)->email);
8059 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8060 : }
8061 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8062 0 : return resultobj;
8063 : fail:
8064 : return NULL;
8065 : }
8066 :
8067 :
8068 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8069 0 : PyObject *resultobj = 0;
8070 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8071 0 : char *arg2 = (char *) 0 ;
8072 0 : void *argp1 = 0 ;
8073 0 : int res1 = 0 ;
8074 : int res2 ;
8075 0 : char *buf2 = 0 ;
8076 0 : int alloc2 = 0 ;
8077 0 : PyObject * obj0 = 0 ;
8078 0 : PyObject * obj1 = 0 ;
8079 :
8080 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_comment_set",&obj0,&obj1)) SWIG_fail;
8081 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8082 0 : if (!SWIG_IsOK(res1)) {
8083 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8084 : }
8085 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8086 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8087 0 : if (!SWIG_IsOK(res2)) {
8088 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_comment_set" "', argument " "2"" of type '" "char *""'");
8089 : }
8090 0 : arg2 = (char *)(buf2);
8091 : {
8092 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8093 0 : if (arg1->comment) free((char*)arg1->comment);
8094 0 : if (arg2) {
8095 0 : size_t size = strlen((const char *)(arg2)) + 1;
8096 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8097 : } else {
8098 0 : arg1->comment = 0;
8099 : }
8100 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8101 : }
8102 0 : resultobj = SWIG_Py_Void();
8103 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8104 : return resultobj;
8105 : fail:
8106 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8107 : return NULL;
8108 : }
8109 :
8110 :
8111 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_comment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8112 0 : PyObject *resultobj = 0;
8113 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8114 0 : void *argp1 = 0 ;
8115 0 : int res1 = 0 ;
8116 0 : PyObject * obj0 = 0 ;
8117 0 : char *result = 0 ;
8118 :
8119 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_comment_get",&obj0)) SWIG_fail;
8120 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8121 0 : if (!SWIG_IsOK(res1)) {
8122 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_comment_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8123 : }
8124 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8125 : {
8126 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8127 0 : result = (char *) ((arg1)->comment);
8128 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8129 : }
8130 0 : resultobj = SWIG_FromCharPtr((const char *)result);
8131 0 : return resultobj;
8132 : fail:
8133 : return NULL;
8134 : }
8135 :
8136 :
8137 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8138 0 : PyObject *resultobj = 0;
8139 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8140 : unsigned int arg2 ;
8141 0 : void *argp1 = 0 ;
8142 0 : int res1 = 0 ;
8143 : unsigned int val2 ;
8144 0 : int ecode2 = 0 ;
8145 0 : PyObject * obj0 = 0 ;
8146 0 : PyObject * obj1 = 0 ;
8147 :
8148 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_sig_class_set",&obj0,&obj1)) SWIG_fail;
8149 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8150 0 : if (!SWIG_IsOK(res1)) {
8151 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8152 : }
8153 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8154 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8155 0 : if (!SWIG_IsOK(ecode2)) {
8156 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_sig_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
8157 : }
8158 0 : arg2 = (unsigned int)(val2);
8159 : {
8160 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8161 0 : if (arg1) (arg1)->sig_class = arg2;
8162 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8163 : }
8164 0 : resultobj = SWIG_Py_Void();
8165 0 : return resultobj;
8166 : fail:
8167 : return NULL;
8168 : }
8169 :
8170 :
8171 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_sig_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8172 0 : PyObject *resultobj = 0;
8173 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8174 0 : void *argp1 = 0 ;
8175 0 : int res1 = 0 ;
8176 0 : PyObject * obj0 = 0 ;
8177 : unsigned int result;
8178 :
8179 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_sig_class_get",&obj0)) SWIG_fail;
8180 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8181 0 : if (!SWIG_IsOK(res1)) {
8182 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8183 : }
8184 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8185 : {
8186 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8187 0 : result = (unsigned int) ((arg1)->sig_class);
8188 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8189 : }
8190 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8191 0 : return resultobj;
8192 : fail:
8193 : return NULL;
8194 : }
8195 :
8196 :
8197 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8198 0 : PyObject *resultobj = 0;
8199 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8200 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
8201 0 : void *argp1 = 0 ;
8202 0 : int res1 = 0 ;
8203 0 : void *argp2 = 0 ;
8204 0 : int res2 = 0 ;
8205 0 : PyObject * obj0 = 0 ;
8206 0 : PyObject * obj1 = 0 ;
8207 :
8208 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig_notations_set",&obj0,&obj1)) SWIG_fail;
8209 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8210 0 : if (!SWIG_IsOK(res1)) {
8211 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8212 : }
8213 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8214 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
8215 0 : if (!SWIG_IsOK(res2)) {
8216 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
8217 : }
8218 0 : arg2 = (gpgme_sig_notation_t)(argp2);
8219 : {
8220 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8221 0 : if (arg1) (arg1)->notations = arg2;
8222 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8223 : }
8224 0 : resultobj = SWIG_Py_Void();
8225 0 : return resultobj;
8226 : fail:
8227 : return NULL;
8228 : }
8229 :
8230 :
8231 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig_notations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8232 0 : PyObject *resultobj = 0;
8233 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8234 0 : void *argp1 = 0 ;
8235 0 : int res1 = 0 ;
8236 0 : PyObject * obj0 = 0 ;
8237 : gpgme_sig_notation_t result;
8238 :
8239 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig_notations_get",&obj0)) SWIG_fail;
8240 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8241 0 : if (!SWIG_IsOK(res1)) {
8242 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig_notations_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8243 : }
8244 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8245 : {
8246 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8247 0 : result = (gpgme_sig_notation_t) ((arg1)->notations);
8248 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8249 : }
8250 : {
8251 : int i;
8252 0 : int size = 0;
8253 : gpgme_sig_notation_t curr;
8254 0 : for (curr = result; curr != NULL; curr = curr->next) {
8255 0 : size++;
8256 : }
8257 0 : resultobj = PyList_New(size);
8258 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8259 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
8260 0 : PyList_SetItem(resultobj, i, o);
8261 : }
8262 : }
8263 : return resultobj;
8264 : fail:
8265 : return NULL;
8266 : }
8267 :
8268 :
8269 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8270 0 : PyObject *resultobj = 0;
8271 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8272 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
8273 0 : void *argp1 = 0 ;
8274 0 : int res1 = 0 ;
8275 0 : void *argp2 = 0 ;
8276 0 : int res2 = 0 ;
8277 0 : PyObject * obj0 = 0 ;
8278 0 : PyObject * obj1 = 0 ;
8279 :
8280 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_sig__last_notation_set",&obj0,&obj1)) SWIG_fail;
8281 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8282 0 : if (!SWIG_IsOK(res1)) {
8283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8284 : }
8285 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8286 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
8287 0 : if (!SWIG_IsOK(res2)) {
8288 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_sig__last_notation_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
8289 : }
8290 0 : arg2 = (gpgme_sig_notation_t)(argp2);
8291 : {
8292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8293 0 : if (arg1) (arg1)->_last_notation = arg2;
8294 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8295 : }
8296 0 : resultobj = SWIG_Py_Void();
8297 0 : return resultobj;
8298 : fail:
8299 : return NULL;
8300 : }
8301 :
8302 :
8303 0 : SWIGINTERN PyObject *_wrap__gpgme_key_sig__last_notation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8304 0 : PyObject *resultobj = 0;
8305 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8306 0 : void *argp1 = 0 ;
8307 0 : int res1 = 0 ;
8308 0 : PyObject * obj0 = 0 ;
8309 : gpgme_sig_notation_t result;
8310 :
8311 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_sig__last_notation_get",&obj0)) SWIG_fail;
8312 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, 0 | 0 );
8313 0 : if (!SWIG_IsOK(res1)) {
8314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_sig__last_notation_get" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8315 : }
8316 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8317 : {
8318 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8319 0 : result = (gpgme_sig_notation_t) ((arg1)->_last_notation);
8320 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8321 : }
8322 : {
8323 : int i;
8324 0 : int size = 0;
8325 : gpgme_sig_notation_t curr;
8326 0 : for (curr = result; curr != NULL; curr = curr->next) {
8327 0 : size++;
8328 : }
8329 0 : resultobj = PyList_New(size);
8330 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8331 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
8332 0 : PyList_SetItem(resultobj, i, o);
8333 : }
8334 : }
8335 : return resultobj;
8336 : fail:
8337 : return NULL;
8338 : }
8339 :
8340 :
8341 0 : SWIGINTERN PyObject *_wrap_new__gpgme_key_sig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8342 0 : PyObject *resultobj = 0;
8343 0 : struct _gpgme_key_sig *result = 0 ;
8344 :
8345 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_key_sig")) SWIG_fail;
8346 : {
8347 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8348 0 : result = (struct _gpgme_key_sig *)calloc(1, sizeof(struct _gpgme_key_sig));
8349 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8350 : }
8351 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_NEW | 0 );
8352 0 : return resultobj;
8353 : fail:
8354 : return NULL;
8355 : }
8356 :
8357 :
8358 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key_sig(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8359 0 : PyObject *resultobj = 0;
8360 0 : struct _gpgme_key_sig *arg1 = (struct _gpgme_key_sig *) 0 ;
8361 0 : void *argp1 = 0 ;
8362 0 : int res1 = 0 ;
8363 0 : PyObject * obj0 = 0 ;
8364 :
8365 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_key_sig",&obj0)) SWIG_fail;
8366 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8367 0 : if (!SWIG_IsOK(res1)) {
8368 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key_sig" "', argument " "1"" of type '" "struct _gpgme_key_sig *""'");
8369 : }
8370 0 : arg1 = (struct _gpgme_key_sig *)(argp1);
8371 : {
8372 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8373 0 : free((char *) arg1);
8374 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8375 : }
8376 0 : resultobj = SWIG_Py_Void();
8377 0 : return resultobj;
8378 : fail:
8379 : return NULL;
8380 : }
8381 :
8382 :
8383 27 : SWIGINTERN PyObject *_gpgme_key_sig_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8384 : PyObject *obj;
8385 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
8386 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_key_sig, SWIG_NewClientData(obj));
8387 27 : return SWIG_Py_Void();
8388 : }
8389 :
8390 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8391 0 : PyObject *resultobj = 0;
8392 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8393 : unsigned int arg2 ;
8394 0 : void *argp1 = 0 ;
8395 0 : int res1 = 0 ;
8396 : unsigned int val2 ;
8397 0 : int ecode2 = 0 ;
8398 0 : PyObject * obj0 = 0 ;
8399 0 : PyObject * obj1 = 0 ;
8400 :
8401 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_revoked_set",&obj0,&obj1)) SWIG_fail;
8402 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8403 0 : if (!SWIG_IsOK(res1)) {
8404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8405 : }
8406 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8407 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8408 0 : if (!SWIG_IsOK(ecode2)) {
8409 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
8410 : }
8411 0 : arg2 = (unsigned int)(val2);
8412 : {
8413 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8414 0 : if (arg1) (arg1)->revoked = arg2;
8415 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8416 : }
8417 0 : resultobj = SWIG_Py_Void();
8418 0 : return resultobj;
8419 : fail:
8420 : return NULL;
8421 : }
8422 :
8423 :
8424 70 : SWIGINTERN PyObject *_wrap__gpgme_user_id_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8425 70 : PyObject *resultobj = 0;
8426 70 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8427 70 : void *argp1 = 0 ;
8428 70 : int res1 = 0 ;
8429 70 : PyObject * obj0 = 0 ;
8430 : unsigned int result;
8431 :
8432 70 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_revoked_get",&obj0)) SWIG_fail;
8433 70 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8434 70 : if (!SWIG_IsOK(res1)) {
8435 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_revoked_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8436 : }
8437 70 : arg1 = (struct _gpgme_user_id *)(argp1);
8438 : {
8439 70 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8440 70 : result = (unsigned int) ((arg1)->revoked);
8441 70 : SWIG_PYTHON_THREAD_END_ALLOW;
8442 : }
8443 70 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8444 70 : return resultobj;
8445 : fail:
8446 : return NULL;
8447 : }
8448 :
8449 :
8450 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8451 0 : PyObject *resultobj = 0;
8452 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8453 : unsigned int arg2 ;
8454 0 : void *argp1 = 0 ;
8455 0 : int res1 = 0 ;
8456 : unsigned int val2 ;
8457 0 : int ecode2 = 0 ;
8458 0 : PyObject * obj0 = 0 ;
8459 0 : PyObject * obj1 = 0 ;
8460 :
8461 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_invalid_set",&obj0,&obj1)) SWIG_fail;
8462 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8463 0 : if (!SWIG_IsOK(res1)) {
8464 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8465 : }
8466 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8467 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8468 0 : if (!SWIG_IsOK(ecode2)) {
8469 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
8470 : }
8471 0 : arg2 = (unsigned int)(val2);
8472 : {
8473 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8474 0 : if (arg1) (arg1)->invalid = arg2;
8475 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8476 : }
8477 0 : resultobj = SWIG_Py_Void();
8478 0 : return resultobj;
8479 : fail:
8480 : return NULL;
8481 : }
8482 :
8483 :
8484 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8485 64 : PyObject *resultobj = 0;
8486 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8487 64 : void *argp1 = 0 ;
8488 64 : int res1 = 0 ;
8489 64 : PyObject * obj0 = 0 ;
8490 : unsigned int result;
8491 :
8492 64 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_invalid_get",&obj0)) SWIG_fail;
8493 64 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8494 64 : if (!SWIG_IsOK(res1)) {
8495 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_invalid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8496 : }
8497 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8498 : {
8499 64 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8500 64 : result = (unsigned int) ((arg1)->invalid);
8501 64 : SWIG_PYTHON_THREAD_END_ALLOW;
8502 : }
8503 64 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8504 64 : return resultobj;
8505 : fail:
8506 : return NULL;
8507 : }
8508 :
8509 :
8510 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8511 0 : PyObject *resultobj = 0;
8512 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8513 : unsigned int arg2 ;
8514 0 : void *argp1 = 0 ;
8515 0 : int res1 = 0 ;
8516 : unsigned int val2 ;
8517 0 : int ecode2 = 0 ;
8518 0 : PyObject * obj0 = 0 ;
8519 0 : PyObject * obj1 = 0 ;
8520 :
8521 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id__unused_set",&obj0,&obj1)) SWIG_fail;
8522 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8523 0 : if (!SWIG_IsOK(res1)) {
8524 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8525 : }
8526 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8527 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
8528 0 : if (!SWIG_IsOK(ecode2)) {
8529 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id__unused_set" "', argument " "2"" of type '" "unsigned int""'");
8530 : }
8531 0 : arg2 = (unsigned int)(val2);
8532 : {
8533 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8534 0 : if (arg1) (arg1)->_unused = arg2;
8535 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8536 : }
8537 0 : resultobj = SWIG_Py_Void();
8538 0 : return resultobj;
8539 : fail:
8540 : return NULL;
8541 : }
8542 :
8543 :
8544 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8545 0 : PyObject *resultobj = 0;
8546 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8547 0 : void *argp1 = 0 ;
8548 0 : int res1 = 0 ;
8549 0 : PyObject * obj0 = 0 ;
8550 : unsigned int result;
8551 :
8552 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__unused_get",&obj0)) SWIG_fail;
8553 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8554 0 : if (!SWIG_IsOK(res1)) {
8555 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__unused_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8556 : }
8557 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8558 : {
8559 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8560 0 : result = (unsigned int) ((arg1)->_unused);
8561 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8562 : }
8563 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
8564 0 : return resultobj;
8565 : fail:
8566 : return NULL;
8567 : }
8568 :
8569 :
8570 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8571 0 : PyObject *resultobj = 0;
8572 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8573 : gpgme_validity_t arg2 ;
8574 0 : void *argp1 = 0 ;
8575 0 : int res1 = 0 ;
8576 : int val2 ;
8577 0 : int ecode2 = 0 ;
8578 0 : PyObject * obj0 = 0 ;
8579 0 : PyObject * obj1 = 0 ;
8580 :
8581 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_validity_set",&obj0,&obj1)) SWIG_fail;
8582 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8583 0 : if (!SWIG_IsOK(res1)) {
8584 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8585 : }
8586 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8587 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
8588 0 : if (!SWIG_IsOK(ecode2)) {
8589 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_user_id_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
8590 : }
8591 0 : arg2 = (gpgme_validity_t)(val2);
8592 : {
8593 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8594 0 : if (arg1) (arg1)->validity = arg2;
8595 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8596 : }
8597 0 : resultobj = SWIG_Py_Void();
8598 0 : return resultobj;
8599 : fail:
8600 : return NULL;
8601 : }
8602 :
8603 :
8604 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8605 64 : PyObject *resultobj = 0;
8606 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8607 64 : void *argp1 = 0 ;
8608 64 : int res1 = 0 ;
8609 64 : PyObject * obj0 = 0 ;
8610 : gpgme_validity_t result;
8611 :
8612 64 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_validity_get",&obj0)) SWIG_fail;
8613 64 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8614 64 : if (!SWIG_IsOK(res1)) {
8615 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_validity_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8616 : }
8617 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8618 : {
8619 64 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8620 64 : result = (gpgme_validity_t) ((arg1)->validity);
8621 64 : SWIG_PYTHON_THREAD_END_ALLOW;
8622 : }
8623 128 : resultobj = SWIG_From_int((int)(result));
8624 64 : return resultobj;
8625 : fail:
8626 : return NULL;
8627 : }
8628 :
8629 :
8630 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8631 0 : PyObject *resultobj = 0;
8632 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8633 0 : char *arg2 = (char *) 0 ;
8634 0 : void *argp1 = 0 ;
8635 0 : int res1 = 0 ;
8636 : int res2 ;
8637 0 : char *buf2 = 0 ;
8638 0 : int alloc2 = 0 ;
8639 0 : PyObject * obj0 = 0 ;
8640 0 : PyObject * obj1 = 0 ;
8641 :
8642 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_uid_set",&obj0,&obj1)) SWIG_fail;
8643 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8644 0 : if (!SWIG_IsOK(res1)) {
8645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8646 : }
8647 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8648 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8649 0 : if (!SWIG_IsOK(res2)) {
8650 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_uid_set" "', argument " "2"" of type '" "char *""'");
8651 : }
8652 0 : arg2 = (char *)(buf2);
8653 : {
8654 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8655 0 : if (arg1->uid) free((char*)arg1->uid);
8656 0 : if (arg2) {
8657 0 : size_t size = strlen((const char *)(arg2)) + 1;
8658 0 : arg1->uid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8659 : } else {
8660 0 : arg1->uid = 0;
8661 : }
8662 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8663 : }
8664 0 : resultobj = SWIG_Py_Void();
8665 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8666 : return resultobj;
8667 : fail:
8668 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8669 : return NULL;
8670 : }
8671 :
8672 :
8673 36 : SWIGINTERN PyObject *_wrap__gpgme_user_id_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8674 36 : PyObject *resultobj = 0;
8675 36 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8676 36 : void *argp1 = 0 ;
8677 36 : int res1 = 0 ;
8678 36 : PyObject * obj0 = 0 ;
8679 36 : char *result = 0 ;
8680 :
8681 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_uid_get",&obj0)) SWIG_fail;
8682 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8683 36 : if (!SWIG_IsOK(res1)) {
8684 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_uid_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8685 : }
8686 36 : arg1 = (struct _gpgme_user_id *)(argp1);
8687 : {
8688 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8689 36 : result = (char *) ((arg1)->uid);
8690 36 : SWIG_PYTHON_THREAD_END_ALLOW;
8691 : }
8692 36 : resultobj = SWIG_FromCharPtr((const char *)result);
8693 36 : return resultobj;
8694 : fail:
8695 : return NULL;
8696 : }
8697 :
8698 :
8699 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8700 0 : PyObject *resultobj = 0;
8701 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8702 0 : char *arg2 = (char *) 0 ;
8703 0 : void *argp1 = 0 ;
8704 0 : int res1 = 0 ;
8705 : int res2 ;
8706 0 : char *buf2 = 0 ;
8707 0 : int alloc2 = 0 ;
8708 0 : PyObject * obj0 = 0 ;
8709 0 : PyObject * obj1 = 0 ;
8710 :
8711 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_name_set",&obj0,&obj1)) SWIG_fail;
8712 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8713 0 : if (!SWIG_IsOK(res1)) {
8714 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8715 : }
8716 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8717 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8718 0 : if (!SWIG_IsOK(res2)) {
8719 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_name_set" "', argument " "2"" of type '" "char *""'");
8720 : }
8721 0 : arg2 = (char *)(buf2);
8722 : {
8723 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8724 0 : if (arg1->name) free((char*)arg1->name);
8725 0 : if (arg2) {
8726 0 : size_t size = strlen((const char *)(arg2)) + 1;
8727 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8728 : } else {
8729 0 : arg1->name = 0;
8730 : }
8731 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8732 : }
8733 0 : resultobj = SWIG_Py_Void();
8734 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8735 : return resultobj;
8736 : fail:
8737 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8738 : return NULL;
8739 : }
8740 :
8741 :
8742 232 : SWIGINTERN PyObject *_wrap__gpgme_user_id_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8743 232 : PyObject *resultobj = 0;
8744 232 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8745 232 : void *argp1 = 0 ;
8746 232 : int res1 = 0 ;
8747 232 : PyObject * obj0 = 0 ;
8748 232 : char *result = 0 ;
8749 :
8750 232 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_name_get",&obj0)) SWIG_fail;
8751 232 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8752 232 : if (!SWIG_IsOK(res1)) {
8753 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_name_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8754 : }
8755 232 : arg1 = (struct _gpgme_user_id *)(argp1);
8756 : {
8757 232 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8758 232 : result = (char *) ((arg1)->name);
8759 232 : SWIG_PYTHON_THREAD_END_ALLOW;
8760 : }
8761 232 : resultobj = SWIG_FromCharPtr((const char *)result);
8762 232 : return resultobj;
8763 : fail:
8764 : return NULL;
8765 : }
8766 :
8767 :
8768 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8769 0 : PyObject *resultobj = 0;
8770 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8771 0 : char *arg2 = (char *) 0 ;
8772 0 : void *argp1 = 0 ;
8773 0 : int res1 = 0 ;
8774 : int res2 ;
8775 0 : char *buf2 = 0 ;
8776 0 : int alloc2 = 0 ;
8777 0 : PyObject * obj0 = 0 ;
8778 0 : PyObject * obj1 = 0 ;
8779 :
8780 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_email_set",&obj0,&obj1)) SWIG_fail;
8781 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8782 0 : if (!SWIG_IsOK(res1)) {
8783 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8784 : }
8785 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8786 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8787 0 : if (!SWIG_IsOK(res2)) {
8788 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_email_set" "', argument " "2"" of type '" "char *""'");
8789 : }
8790 0 : arg2 = (char *)(buf2);
8791 : {
8792 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8793 0 : if (arg1->email) free((char*)arg1->email);
8794 0 : if (arg2) {
8795 0 : size_t size = strlen((const char *)(arg2)) + 1;
8796 0 : arg1->email = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8797 : } else {
8798 0 : arg1->email = 0;
8799 : }
8800 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8801 : }
8802 0 : resultobj = SWIG_Py_Void();
8803 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8804 : return resultobj;
8805 : fail:
8806 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8807 : return NULL;
8808 : }
8809 :
8810 :
8811 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_email_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8812 64 : PyObject *resultobj = 0;
8813 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8814 64 : void *argp1 = 0 ;
8815 64 : int res1 = 0 ;
8816 64 : PyObject * obj0 = 0 ;
8817 64 : char *result = 0 ;
8818 :
8819 64 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_email_get",&obj0)) SWIG_fail;
8820 64 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8821 64 : if (!SWIG_IsOK(res1)) {
8822 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_email_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8823 : }
8824 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8825 : {
8826 64 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8827 64 : result = (char *) ((arg1)->email);
8828 64 : SWIG_PYTHON_THREAD_END_ALLOW;
8829 : }
8830 64 : resultobj = SWIG_FromCharPtr((const char *)result);
8831 64 : return resultobj;
8832 : fail:
8833 : return NULL;
8834 : }
8835 :
8836 :
8837 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8838 0 : PyObject *resultobj = 0;
8839 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8840 0 : char *arg2 = (char *) 0 ;
8841 0 : void *argp1 = 0 ;
8842 0 : int res1 = 0 ;
8843 : int res2 ;
8844 0 : char *buf2 = 0 ;
8845 0 : int alloc2 = 0 ;
8846 0 : PyObject * obj0 = 0 ;
8847 0 : PyObject * obj1 = 0 ;
8848 :
8849 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_comment_set",&obj0,&obj1)) SWIG_fail;
8850 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8851 0 : if (!SWIG_IsOK(res1)) {
8852 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8853 : }
8854 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8855 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
8856 0 : if (!SWIG_IsOK(res2)) {
8857 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_comment_set" "', argument " "2"" of type '" "char *""'");
8858 : }
8859 0 : arg2 = (char *)(buf2);
8860 : {
8861 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8862 0 : if (arg1->comment) free((char*)arg1->comment);
8863 0 : if (arg2) {
8864 0 : size_t size = strlen((const char *)(arg2)) + 1;
8865 0 : arg1->comment = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
8866 : } else {
8867 0 : arg1->comment = 0;
8868 : }
8869 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8870 : }
8871 0 : resultobj = SWIG_Py_Void();
8872 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8873 : return resultobj;
8874 : fail:
8875 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
8876 : return NULL;
8877 : }
8878 :
8879 :
8880 64 : SWIGINTERN PyObject *_wrap__gpgme_user_id_comment_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8881 64 : PyObject *resultobj = 0;
8882 64 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8883 64 : void *argp1 = 0 ;
8884 64 : int res1 = 0 ;
8885 64 : PyObject * obj0 = 0 ;
8886 64 : char *result = 0 ;
8887 :
8888 64 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_comment_get",&obj0)) SWIG_fail;
8889 64 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8890 64 : if (!SWIG_IsOK(res1)) {
8891 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_comment_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8892 : }
8893 64 : arg1 = (struct _gpgme_user_id *)(argp1);
8894 : {
8895 64 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8896 64 : result = (char *) ((arg1)->comment);
8897 64 : SWIG_PYTHON_THREAD_END_ALLOW;
8898 : }
8899 64 : resultobj = SWIG_FromCharPtr((const char *)result);
8900 64 : return resultobj;
8901 : fail:
8902 : return NULL;
8903 : }
8904 :
8905 :
8906 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8907 0 : PyObject *resultobj = 0;
8908 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8909 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
8910 0 : void *argp1 = 0 ;
8911 0 : int res1 = 0 ;
8912 0 : void *argp2 = 0 ;
8913 0 : int res2 = 0 ;
8914 0 : PyObject * obj0 = 0 ;
8915 0 : PyObject * obj1 = 0 ;
8916 :
8917 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_signatures_set",&obj0,&obj1)) SWIG_fail;
8918 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8919 0 : if (!SWIG_IsOK(res1)) {
8920 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8921 : }
8922 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8923 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8924 0 : if (!SWIG_IsOK(res2)) {
8925 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_signatures_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
8926 : }
8927 0 : arg2 = (gpgme_key_sig_t)(argp2);
8928 : {
8929 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8930 0 : if (arg1) (arg1)->signatures = arg2;
8931 0 : SWIG_PYTHON_THREAD_END_ALLOW;
8932 : }
8933 0 : resultobj = SWIG_Py_Void();
8934 0 : return resultobj;
8935 : fail:
8936 : return NULL;
8937 : }
8938 :
8939 :
8940 79 : SWIGINTERN PyObject *_wrap__gpgme_user_id_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8941 79 : PyObject *resultobj = 0;
8942 79 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8943 79 : void *argp1 = 0 ;
8944 79 : int res1 = 0 ;
8945 79 : PyObject * obj0 = 0 ;
8946 : gpgme_key_sig_t result;
8947 :
8948 79 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_signatures_get",&obj0)) SWIG_fail;
8949 79 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8950 79 : if (!SWIG_IsOK(res1)) {
8951 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_signatures_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8952 : }
8953 79 : arg1 = (struct _gpgme_user_id *)(argp1);
8954 : {
8955 79 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
8956 79 : result = (gpgme_key_sig_t) ((arg1)->signatures);
8957 79 : SWIG_PYTHON_THREAD_END_ALLOW;
8958 : }
8959 : {
8960 : int i;
8961 79 : int size = 0;
8962 : gpgme_key_sig_t curr;
8963 106 : for (curr = result; curr != NULL; curr = curr->next) {
8964 27 : size++;
8965 : }
8966 79 : resultobj = PyList_New(size);
8967 106 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
8968 27 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
8969 27 : PyList_SetItem(resultobj, i, o);
8970 : }
8971 : }
8972 : return resultobj;
8973 : fail:
8974 : return NULL;
8975 : }
8976 :
8977 :
8978 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8979 0 : PyObject *resultobj = 0;
8980 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
8981 0 : gpgme_key_sig_t arg2 = (gpgme_key_sig_t) 0 ;
8982 0 : void *argp1 = 0 ;
8983 0 : int res1 = 0 ;
8984 0 : void *argp2 = 0 ;
8985 0 : int res2 = 0 ;
8986 0 : PyObject * obj0 = 0 ;
8987 0 : PyObject * obj1 = 0 ;
8988 :
8989 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id__last_keysig_set",&obj0,&obj1)) SWIG_fail;
8990 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
8991 0 : if (!SWIG_IsOK(res1)) {
8992 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
8993 : }
8994 0 : arg1 = (struct _gpgme_user_id *)(argp1);
8995 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key_sig, SWIG_POINTER_DISOWN | 0 );
8996 0 : if (!SWIG_IsOK(res2)) {
8997 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id__last_keysig_set" "', argument " "2"" of type '" "gpgme_key_sig_t""'");
8998 : }
8999 0 : arg2 = (gpgme_key_sig_t)(argp2);
9000 : {
9001 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9002 0 : if (arg1) (arg1)->_last_keysig = arg2;
9003 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9004 : }
9005 0 : resultobj = SWIG_Py_Void();
9006 0 : return resultobj;
9007 : fail:
9008 : return NULL;
9009 : }
9010 :
9011 :
9012 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id__last_keysig_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9013 0 : PyObject *resultobj = 0;
9014 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9015 0 : void *argp1 = 0 ;
9016 0 : int res1 = 0 ;
9017 0 : PyObject * obj0 = 0 ;
9018 : gpgme_key_sig_t result;
9019 :
9020 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id__last_keysig_get",&obj0)) SWIG_fail;
9021 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9022 0 : if (!SWIG_IsOK(res1)) {
9023 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id__last_keysig_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9024 : }
9025 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9026 : {
9027 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9028 0 : result = (gpgme_key_sig_t) ((arg1)->_last_keysig);
9029 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9030 : }
9031 : {
9032 : int i;
9033 0 : int size = 0;
9034 : gpgme_key_sig_t curr;
9035 0 : for (curr = result; curr != NULL; curr = curr->next) {
9036 0 : size++;
9037 : }
9038 0 : resultobj = PyList_New(size);
9039 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9040 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_key_sig, 0 );
9041 0 : PyList_SetItem(resultobj, i, o);
9042 : }
9043 : }
9044 : return resultobj;
9045 : fail:
9046 : return NULL;
9047 : }
9048 :
9049 :
9050 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9051 0 : PyObject *resultobj = 0;
9052 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9053 0 : char *arg2 = (char *) 0 ;
9054 0 : void *argp1 = 0 ;
9055 0 : int res1 = 0 ;
9056 : int res2 ;
9057 0 : char *buf2 = 0 ;
9058 0 : int alloc2 = 0 ;
9059 0 : PyObject * obj0 = 0 ;
9060 0 : PyObject * obj1 = 0 ;
9061 :
9062 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_address_set",&obj0,&obj1)) SWIG_fail;
9063 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9064 0 : if (!SWIG_IsOK(res1)) {
9065 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9066 : }
9067 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9068 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
9069 0 : if (!SWIG_IsOK(res2)) {
9070 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_address_set" "', argument " "2"" of type '" "char *""'");
9071 : }
9072 0 : arg2 = (char *)(buf2);
9073 : {
9074 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9075 0 : if (arg1->address) free((char*)arg1->address);
9076 0 : if (arg2) {
9077 0 : size_t size = strlen((const char *)(arg2)) + 1;
9078 0 : arg1->address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
9079 : } else {
9080 0 : arg1->address = 0;
9081 : }
9082 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9083 : }
9084 0 : resultobj = SWIG_Py_Void();
9085 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9086 : return resultobj;
9087 : fail:
9088 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
9089 : return NULL;
9090 : }
9091 :
9092 :
9093 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9094 0 : PyObject *resultobj = 0;
9095 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9096 0 : void *argp1 = 0 ;
9097 0 : int res1 = 0 ;
9098 0 : PyObject * obj0 = 0 ;
9099 0 : char *result = 0 ;
9100 :
9101 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_address_get",&obj0)) SWIG_fail;
9102 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9103 0 : if (!SWIG_IsOK(res1)) {
9104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_address_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9105 : }
9106 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9107 : {
9108 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9109 0 : result = (char *) ((arg1)->address);
9110 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9111 : }
9112 0 : resultobj = SWIG_FromCharPtr((const char *)result);
9113 0 : return resultobj;
9114 : fail:
9115 : return NULL;
9116 : }
9117 :
9118 :
9119 0 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9120 0 : PyObject *resultobj = 0;
9121 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9122 0 : gpgme_tofu_info_t arg2 = (gpgme_tofu_info_t) 0 ;
9123 0 : void *argp1 = 0 ;
9124 0 : int res1 = 0 ;
9125 0 : void *argp2 = 0 ;
9126 0 : int res2 = 0 ;
9127 0 : PyObject * obj0 = 0 ;
9128 0 : PyObject * obj1 = 0 ;
9129 :
9130 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_user_id_tofu_set",&obj0,&obj1)) SWIG_fail;
9131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9132 0 : if (!SWIG_IsOK(res1)) {
9133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_set" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9134 : }
9135 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9136 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_tofu_info, SWIG_POINTER_DISOWN | 0 );
9137 0 : if (!SWIG_IsOK(res2)) {
9138 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_user_id_tofu_set" "', argument " "2"" of type '" "gpgme_tofu_info_t""'");
9139 : }
9140 0 : arg2 = (gpgme_tofu_info_t)(argp2);
9141 : {
9142 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9143 0 : if (arg1) (arg1)->tofu = arg2;
9144 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9145 : }
9146 0 : resultobj = SWIG_Py_Void();
9147 0 : return resultobj;
9148 : fail:
9149 : return NULL;
9150 : }
9151 :
9152 :
9153 4 : SWIGINTERN PyObject *_wrap__gpgme_user_id_tofu_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9154 4 : PyObject *resultobj = 0;
9155 4 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9156 4 : void *argp1 = 0 ;
9157 4 : int res1 = 0 ;
9158 4 : PyObject * obj0 = 0 ;
9159 : gpgme_tofu_info_t result;
9160 :
9161 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_user_id_tofu_get",&obj0)) SWIG_fail;
9162 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, 0 | 0 );
9163 4 : if (!SWIG_IsOK(res1)) {
9164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_user_id_tofu_get" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9165 : }
9166 4 : arg1 = (struct _gpgme_user_id *)(argp1);
9167 : {
9168 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9169 4 : result = (gpgme_tofu_info_t) ((arg1)->tofu);
9170 4 : SWIG_PYTHON_THREAD_END_ALLOW;
9171 : }
9172 : {
9173 : int i;
9174 4 : int size = 0;
9175 : gpgme_tofu_info_t curr;
9176 8 : for (curr = result; curr != NULL; curr = curr->next) {
9177 4 : size++;
9178 : }
9179 4 : resultobj = PyList_New(size);
9180 8 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
9181 4 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_tofu_info, 0 );
9182 4 : PyList_SetItem(resultobj, i, o);
9183 : }
9184 : }
9185 : return resultobj;
9186 : fail:
9187 : return NULL;
9188 : }
9189 :
9190 :
9191 0 : SWIGINTERN PyObject *_wrap_new__gpgme_user_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9192 0 : PyObject *resultobj = 0;
9193 0 : struct _gpgme_user_id *result = 0 ;
9194 :
9195 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_user_id")) SWIG_fail;
9196 : {
9197 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9198 0 : result = (struct _gpgme_user_id *)calloc(1, sizeof(struct _gpgme_user_id));
9199 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9200 : }
9201 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_NEW | 0 );
9202 0 : return resultobj;
9203 : fail:
9204 : return NULL;
9205 : }
9206 :
9207 :
9208 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_user_id(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9209 0 : PyObject *resultobj = 0;
9210 0 : struct _gpgme_user_id *arg1 = (struct _gpgme_user_id *) 0 ;
9211 0 : void *argp1 = 0 ;
9212 0 : int res1 = 0 ;
9213 0 : PyObject * obj0 = 0 ;
9214 :
9215 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_user_id",&obj0)) SWIG_fail;
9216 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
9217 0 : if (!SWIG_IsOK(res1)) {
9218 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_user_id" "', argument " "1"" of type '" "struct _gpgme_user_id *""'");
9219 : }
9220 0 : arg1 = (struct _gpgme_user_id *)(argp1);
9221 : {
9222 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9223 0 : free((char *) arg1);
9224 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9225 : }
9226 0 : resultobj = SWIG_Py_Void();
9227 0 : return resultobj;
9228 : fail:
9229 : return NULL;
9230 : }
9231 :
9232 :
9233 27 : SWIGINTERN PyObject *_gpgme_user_id_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9234 : PyObject *obj;
9235 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
9236 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_user_id, SWIG_NewClientData(obj));
9237 27 : return SWIG_Py_Void();
9238 : }
9239 :
9240 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9241 0 : PyObject *resultobj = 0;
9242 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9243 : unsigned int arg2 ;
9244 0 : void *argp1 = 0 ;
9245 0 : int res1 = 0 ;
9246 : unsigned int val2 ;
9247 0 : int ecode2 = 0 ;
9248 0 : PyObject * obj0 = 0 ;
9249 0 : PyObject * obj1 = 0 ;
9250 :
9251 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__refs_set",&obj0,&obj1)) SWIG_fail;
9252 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9253 0 : if (!SWIG_IsOK(res1)) {
9254 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9255 : }
9256 0 : arg1 = (struct _gpgme_key *)(argp1);
9257 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9258 0 : if (!SWIG_IsOK(ecode2)) {
9259 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__refs_set" "', argument " "2"" of type '" "unsigned int""'");
9260 : }
9261 0 : arg2 = (unsigned int)(val2);
9262 : {
9263 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9264 0 : if (arg1) (arg1)->_refs = arg2;
9265 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9266 : }
9267 0 : resultobj = SWIG_Py_Void();
9268 0 : return resultobj;
9269 : fail:
9270 : return NULL;
9271 : }
9272 :
9273 :
9274 0 : SWIGINTERN PyObject *_wrap__gpgme_key__refs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9275 0 : PyObject *resultobj = 0;
9276 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9277 0 : void *argp1 = 0 ;
9278 0 : int res1 = 0 ;
9279 0 : PyObject * obj0 = 0 ;
9280 : unsigned int result;
9281 :
9282 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__refs_get",&obj0)) SWIG_fail;
9283 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9284 0 : if (!SWIG_IsOK(res1)) {
9285 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__refs_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9286 : }
9287 0 : arg1 = (struct _gpgme_key *)(argp1);
9288 : {
9289 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9290 0 : result = (unsigned int) ((arg1)->_refs);
9291 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9292 : }
9293 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9294 0 : return resultobj;
9295 : fail:
9296 : return NULL;
9297 : }
9298 :
9299 :
9300 0 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9301 0 : PyObject *resultobj = 0;
9302 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9303 : unsigned int arg2 ;
9304 0 : void *argp1 = 0 ;
9305 0 : int res1 = 0 ;
9306 : unsigned int val2 ;
9307 0 : int ecode2 = 0 ;
9308 0 : PyObject * obj0 = 0 ;
9309 0 : PyObject * obj1 = 0 ;
9310 :
9311 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_revoked_set",&obj0,&obj1)) SWIG_fail;
9312 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9313 0 : if (!SWIG_IsOK(res1)) {
9314 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9315 : }
9316 0 : arg1 = (struct _gpgme_key *)(argp1);
9317 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9318 0 : if (!SWIG_IsOK(ecode2)) {
9319 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_revoked_set" "', argument " "2"" of type '" "unsigned int""'");
9320 : }
9321 0 : arg2 = (unsigned int)(val2);
9322 : {
9323 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9324 0 : if (arg1) (arg1)->revoked = arg2;
9325 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9326 : }
9327 0 : resultobj = SWIG_Py_Void();
9328 0 : return resultobj;
9329 : fail:
9330 : return NULL;
9331 : }
9332 :
9333 :
9334 52 : SWIGINTERN PyObject *_wrap__gpgme_key_revoked_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9335 52 : PyObject *resultobj = 0;
9336 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9337 52 : void *argp1 = 0 ;
9338 52 : int res1 = 0 ;
9339 52 : PyObject * obj0 = 0 ;
9340 : unsigned int result;
9341 :
9342 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_revoked_get",&obj0)) SWIG_fail;
9343 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9344 52 : if (!SWIG_IsOK(res1)) {
9345 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_revoked_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9346 : }
9347 52 : arg1 = (struct _gpgme_key *)(argp1);
9348 : {
9349 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9350 52 : result = (unsigned int) ((arg1)->revoked);
9351 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9352 : }
9353 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9354 52 : return resultobj;
9355 : fail:
9356 : return NULL;
9357 : }
9358 :
9359 :
9360 0 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9361 0 : PyObject *resultobj = 0;
9362 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9363 : unsigned int arg2 ;
9364 0 : void *argp1 = 0 ;
9365 0 : int res1 = 0 ;
9366 : unsigned int val2 ;
9367 0 : int ecode2 = 0 ;
9368 0 : PyObject * obj0 = 0 ;
9369 0 : PyObject * obj1 = 0 ;
9370 :
9371 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_expired_set",&obj0,&obj1)) SWIG_fail;
9372 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9373 0 : if (!SWIG_IsOK(res1)) {
9374 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9375 : }
9376 0 : arg1 = (struct _gpgme_key *)(argp1);
9377 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9378 0 : if (!SWIG_IsOK(ecode2)) {
9379 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_expired_set" "', argument " "2"" of type '" "unsigned int""'");
9380 : }
9381 0 : arg2 = (unsigned int)(val2);
9382 : {
9383 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9384 0 : if (arg1) (arg1)->expired = arg2;
9385 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9386 : }
9387 0 : resultobj = SWIG_Py_Void();
9388 0 : return resultobj;
9389 : fail:
9390 : return NULL;
9391 : }
9392 :
9393 :
9394 52 : SWIGINTERN PyObject *_wrap__gpgme_key_expired_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9395 52 : PyObject *resultobj = 0;
9396 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9397 52 : void *argp1 = 0 ;
9398 52 : int res1 = 0 ;
9399 52 : PyObject * obj0 = 0 ;
9400 : unsigned int result;
9401 :
9402 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_expired_get",&obj0)) SWIG_fail;
9403 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9404 52 : if (!SWIG_IsOK(res1)) {
9405 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_expired_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9406 : }
9407 52 : arg1 = (struct _gpgme_key *)(argp1);
9408 : {
9409 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9410 52 : result = (unsigned int) ((arg1)->expired);
9411 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9412 : }
9413 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9414 52 : return resultobj;
9415 : fail:
9416 : return NULL;
9417 : }
9418 :
9419 :
9420 0 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9421 0 : PyObject *resultobj = 0;
9422 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9423 : unsigned int arg2 ;
9424 0 : void *argp1 = 0 ;
9425 0 : int res1 = 0 ;
9426 : unsigned int val2 ;
9427 0 : int ecode2 = 0 ;
9428 0 : PyObject * obj0 = 0 ;
9429 0 : PyObject * obj1 = 0 ;
9430 :
9431 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_disabled_set",&obj0,&obj1)) SWIG_fail;
9432 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9433 0 : if (!SWIG_IsOK(res1)) {
9434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9435 : }
9436 0 : arg1 = (struct _gpgme_key *)(argp1);
9437 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9438 0 : if (!SWIG_IsOK(ecode2)) {
9439 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_disabled_set" "', argument " "2"" of type '" "unsigned int""'");
9440 : }
9441 0 : arg2 = (unsigned int)(val2);
9442 : {
9443 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9444 0 : if (arg1) (arg1)->disabled = arg2;
9445 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9446 : }
9447 0 : resultobj = SWIG_Py_Void();
9448 0 : return resultobj;
9449 : fail:
9450 : return NULL;
9451 : }
9452 :
9453 :
9454 52 : SWIGINTERN PyObject *_wrap__gpgme_key_disabled_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9455 52 : PyObject *resultobj = 0;
9456 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9457 52 : void *argp1 = 0 ;
9458 52 : int res1 = 0 ;
9459 52 : PyObject * obj0 = 0 ;
9460 : unsigned int result;
9461 :
9462 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_disabled_get",&obj0)) SWIG_fail;
9463 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9464 52 : if (!SWIG_IsOK(res1)) {
9465 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_disabled_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9466 : }
9467 52 : arg1 = (struct _gpgme_key *)(argp1);
9468 : {
9469 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9470 52 : result = (unsigned int) ((arg1)->disabled);
9471 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9472 : }
9473 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9474 52 : return resultobj;
9475 : fail:
9476 : return NULL;
9477 : }
9478 :
9479 :
9480 0 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9481 0 : PyObject *resultobj = 0;
9482 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9483 : unsigned int arg2 ;
9484 0 : void *argp1 = 0 ;
9485 0 : int res1 = 0 ;
9486 : unsigned int val2 ;
9487 0 : int ecode2 = 0 ;
9488 0 : PyObject * obj0 = 0 ;
9489 0 : PyObject * obj1 = 0 ;
9490 :
9491 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_invalid_set",&obj0,&obj1)) SWIG_fail;
9492 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9493 0 : if (!SWIG_IsOK(res1)) {
9494 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9495 : }
9496 0 : arg1 = (struct _gpgme_key *)(argp1);
9497 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9498 0 : if (!SWIG_IsOK(ecode2)) {
9499 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_invalid_set" "', argument " "2"" of type '" "unsigned int""'");
9500 : }
9501 0 : arg2 = (unsigned int)(val2);
9502 : {
9503 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9504 0 : if (arg1) (arg1)->invalid = arg2;
9505 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9506 : }
9507 0 : resultobj = SWIG_Py_Void();
9508 0 : return resultobj;
9509 : fail:
9510 : return NULL;
9511 : }
9512 :
9513 :
9514 52 : SWIGINTERN PyObject *_wrap__gpgme_key_invalid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9515 52 : PyObject *resultobj = 0;
9516 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9517 52 : void *argp1 = 0 ;
9518 52 : int res1 = 0 ;
9519 52 : PyObject * obj0 = 0 ;
9520 : unsigned int result;
9521 :
9522 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_invalid_get",&obj0)) SWIG_fail;
9523 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9524 52 : if (!SWIG_IsOK(res1)) {
9525 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_invalid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9526 : }
9527 52 : arg1 = (struct _gpgme_key *)(argp1);
9528 : {
9529 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9530 52 : result = (unsigned int) ((arg1)->invalid);
9531 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9532 : }
9533 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9534 52 : return resultobj;
9535 : fail:
9536 : return NULL;
9537 : }
9538 :
9539 :
9540 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9541 0 : PyObject *resultobj = 0;
9542 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9543 : unsigned int arg2 ;
9544 0 : void *argp1 = 0 ;
9545 0 : int res1 = 0 ;
9546 : unsigned int val2 ;
9547 0 : int ecode2 = 0 ;
9548 0 : PyObject * obj0 = 0 ;
9549 0 : PyObject * obj1 = 0 ;
9550 :
9551 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_encrypt_set",&obj0,&obj1)) SWIG_fail;
9552 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9553 0 : if (!SWIG_IsOK(res1)) {
9554 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9555 : }
9556 0 : arg1 = (struct _gpgme_key *)(argp1);
9557 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9558 0 : if (!SWIG_IsOK(ecode2)) {
9559 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_encrypt_set" "', argument " "2"" of type '" "unsigned int""'");
9560 : }
9561 0 : arg2 = (unsigned int)(val2);
9562 : {
9563 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9564 0 : if (arg1) (arg1)->can_encrypt = arg2;
9565 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9566 : }
9567 0 : resultobj = SWIG_Py_Void();
9568 0 : return resultobj;
9569 : fail:
9570 : return NULL;
9571 : }
9572 :
9573 :
9574 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_encrypt_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9575 0 : PyObject *resultobj = 0;
9576 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9577 0 : void *argp1 = 0 ;
9578 0 : int res1 = 0 ;
9579 0 : PyObject * obj0 = 0 ;
9580 : unsigned int result;
9581 :
9582 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_encrypt_get",&obj0)) SWIG_fail;
9583 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9584 0 : if (!SWIG_IsOK(res1)) {
9585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_encrypt_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9586 : }
9587 0 : arg1 = (struct _gpgme_key *)(argp1);
9588 : {
9589 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9590 0 : result = (unsigned int) ((arg1)->can_encrypt);
9591 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9592 : }
9593 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9594 0 : return resultobj;
9595 : fail:
9596 : return NULL;
9597 : }
9598 :
9599 :
9600 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9601 0 : PyObject *resultobj = 0;
9602 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9603 : unsigned int arg2 ;
9604 0 : void *argp1 = 0 ;
9605 0 : int res1 = 0 ;
9606 : unsigned int val2 ;
9607 0 : int ecode2 = 0 ;
9608 0 : PyObject * obj0 = 0 ;
9609 0 : PyObject * obj1 = 0 ;
9610 :
9611 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_sign_set",&obj0,&obj1)) SWIG_fail;
9612 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9613 0 : if (!SWIG_IsOK(res1)) {
9614 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9615 : }
9616 0 : arg1 = (struct _gpgme_key *)(argp1);
9617 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9618 0 : if (!SWIG_IsOK(ecode2)) {
9619 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_sign_set" "', argument " "2"" of type '" "unsigned int""'");
9620 : }
9621 0 : arg2 = (unsigned int)(val2);
9622 : {
9623 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9624 0 : if (arg1) (arg1)->can_sign = arg2;
9625 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9626 : }
9627 0 : resultobj = SWIG_Py_Void();
9628 0 : return resultobj;
9629 : fail:
9630 : return NULL;
9631 : }
9632 :
9633 :
9634 52 : SWIGINTERN PyObject *_wrap__gpgme_key_can_sign_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9635 52 : PyObject *resultobj = 0;
9636 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9637 52 : void *argp1 = 0 ;
9638 52 : int res1 = 0 ;
9639 52 : PyObject * obj0 = 0 ;
9640 : unsigned int result;
9641 :
9642 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_sign_get",&obj0)) SWIG_fail;
9643 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9644 52 : if (!SWIG_IsOK(res1)) {
9645 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_sign_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9646 : }
9647 52 : arg1 = (struct _gpgme_key *)(argp1);
9648 : {
9649 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9650 52 : result = (unsigned int) ((arg1)->can_sign);
9651 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9652 : }
9653 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9654 52 : return resultobj;
9655 : fail:
9656 : return NULL;
9657 : }
9658 :
9659 :
9660 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9661 0 : PyObject *resultobj = 0;
9662 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9663 : unsigned int arg2 ;
9664 0 : void *argp1 = 0 ;
9665 0 : int res1 = 0 ;
9666 : unsigned int val2 ;
9667 0 : int ecode2 = 0 ;
9668 0 : PyObject * obj0 = 0 ;
9669 0 : PyObject * obj1 = 0 ;
9670 :
9671 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_certify_set",&obj0,&obj1)) SWIG_fail;
9672 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9673 0 : if (!SWIG_IsOK(res1)) {
9674 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9675 : }
9676 0 : arg1 = (struct _gpgme_key *)(argp1);
9677 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9678 0 : if (!SWIG_IsOK(ecode2)) {
9679 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_certify_set" "', argument " "2"" of type '" "unsigned int""'");
9680 : }
9681 0 : arg2 = (unsigned int)(val2);
9682 : {
9683 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9684 0 : if (arg1) (arg1)->can_certify = arg2;
9685 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9686 : }
9687 0 : resultobj = SWIG_Py_Void();
9688 0 : return resultobj;
9689 : fail:
9690 : return NULL;
9691 : }
9692 :
9693 :
9694 52 : SWIGINTERN PyObject *_wrap__gpgme_key_can_certify_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9695 52 : PyObject *resultobj = 0;
9696 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9697 52 : void *argp1 = 0 ;
9698 52 : int res1 = 0 ;
9699 52 : PyObject * obj0 = 0 ;
9700 : unsigned int result;
9701 :
9702 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_certify_get",&obj0)) SWIG_fail;
9703 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9704 52 : if (!SWIG_IsOK(res1)) {
9705 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_certify_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9706 : }
9707 52 : arg1 = (struct _gpgme_key *)(argp1);
9708 : {
9709 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9710 52 : result = (unsigned int) ((arg1)->can_certify);
9711 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9712 : }
9713 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9714 52 : return resultobj;
9715 : fail:
9716 : return NULL;
9717 : }
9718 :
9719 :
9720 0 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9721 0 : PyObject *resultobj = 0;
9722 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9723 : unsigned int arg2 ;
9724 0 : void *argp1 = 0 ;
9725 0 : int res1 = 0 ;
9726 : unsigned int val2 ;
9727 0 : int ecode2 = 0 ;
9728 0 : PyObject * obj0 = 0 ;
9729 0 : PyObject * obj1 = 0 ;
9730 :
9731 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_secret_set",&obj0,&obj1)) SWIG_fail;
9732 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9733 0 : if (!SWIG_IsOK(res1)) {
9734 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9735 : }
9736 0 : arg1 = (struct _gpgme_key *)(argp1);
9737 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9738 0 : if (!SWIG_IsOK(ecode2)) {
9739 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_secret_set" "', argument " "2"" of type '" "unsigned int""'");
9740 : }
9741 0 : arg2 = (unsigned int)(val2);
9742 : {
9743 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9744 0 : if (arg1) (arg1)->secret = arg2;
9745 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9746 : }
9747 0 : resultobj = SWIG_Py_Void();
9748 0 : return resultobj;
9749 : fail:
9750 : return NULL;
9751 : }
9752 :
9753 :
9754 52 : SWIGINTERN PyObject *_wrap__gpgme_key_secret_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9755 52 : PyObject *resultobj = 0;
9756 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9757 52 : void *argp1 = 0 ;
9758 52 : int res1 = 0 ;
9759 52 : PyObject * obj0 = 0 ;
9760 : unsigned int result;
9761 :
9762 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_secret_get",&obj0)) SWIG_fail;
9763 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9764 52 : if (!SWIG_IsOK(res1)) {
9765 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_secret_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9766 : }
9767 52 : arg1 = (struct _gpgme_key *)(argp1);
9768 : {
9769 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9770 52 : result = (unsigned int) ((arg1)->secret);
9771 52 : SWIG_PYTHON_THREAD_END_ALLOW;
9772 : }
9773 52 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9774 52 : return resultobj;
9775 : fail:
9776 : return NULL;
9777 : }
9778 :
9779 :
9780 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9781 0 : PyObject *resultobj = 0;
9782 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9783 : unsigned int arg2 ;
9784 0 : void *argp1 = 0 ;
9785 0 : int res1 = 0 ;
9786 : unsigned int val2 ;
9787 0 : int ecode2 = 0 ;
9788 0 : PyObject * obj0 = 0 ;
9789 0 : PyObject * obj1 = 0 ;
9790 :
9791 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_can_authenticate_set",&obj0,&obj1)) SWIG_fail;
9792 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9793 0 : if (!SWIG_IsOK(res1)) {
9794 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9795 : }
9796 0 : arg1 = (struct _gpgme_key *)(argp1);
9797 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9798 0 : if (!SWIG_IsOK(ecode2)) {
9799 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_can_authenticate_set" "', argument " "2"" of type '" "unsigned int""'");
9800 : }
9801 0 : arg2 = (unsigned int)(val2);
9802 : {
9803 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9804 0 : if (arg1) (arg1)->can_authenticate = arg2;
9805 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9806 : }
9807 0 : resultobj = SWIG_Py_Void();
9808 0 : return resultobj;
9809 : fail:
9810 : return NULL;
9811 : }
9812 :
9813 :
9814 0 : SWIGINTERN PyObject *_wrap__gpgme_key_can_authenticate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9815 0 : PyObject *resultobj = 0;
9816 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9817 0 : void *argp1 = 0 ;
9818 0 : int res1 = 0 ;
9819 0 : PyObject * obj0 = 0 ;
9820 : unsigned int result;
9821 :
9822 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_can_authenticate_get",&obj0)) SWIG_fail;
9823 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9824 0 : if (!SWIG_IsOK(res1)) {
9825 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_can_authenticate_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9826 : }
9827 0 : arg1 = (struct _gpgme_key *)(argp1);
9828 : {
9829 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9830 0 : result = (unsigned int) ((arg1)->can_authenticate);
9831 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9832 : }
9833 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9834 0 : return resultobj;
9835 : fail:
9836 : return NULL;
9837 : }
9838 :
9839 :
9840 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9841 0 : PyObject *resultobj = 0;
9842 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9843 : unsigned int arg2 ;
9844 0 : void *argp1 = 0 ;
9845 0 : int res1 = 0 ;
9846 : unsigned int val2 ;
9847 0 : int ecode2 = 0 ;
9848 0 : PyObject * obj0 = 0 ;
9849 0 : PyObject * obj1 = 0 ;
9850 :
9851 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_is_qualified_set",&obj0,&obj1)) SWIG_fail;
9852 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9853 0 : if (!SWIG_IsOK(res1)) {
9854 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9855 : }
9856 0 : arg1 = (struct _gpgme_key *)(argp1);
9857 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9858 0 : if (!SWIG_IsOK(ecode2)) {
9859 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_is_qualified_set" "', argument " "2"" of type '" "unsigned int""'");
9860 : }
9861 0 : arg2 = (unsigned int)(val2);
9862 : {
9863 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9864 0 : if (arg1) (arg1)->is_qualified = arg2;
9865 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9866 : }
9867 0 : resultobj = SWIG_Py_Void();
9868 0 : return resultobj;
9869 : fail:
9870 : return NULL;
9871 : }
9872 :
9873 :
9874 0 : SWIGINTERN PyObject *_wrap__gpgme_key_is_qualified_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9875 0 : PyObject *resultobj = 0;
9876 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9877 0 : void *argp1 = 0 ;
9878 0 : int res1 = 0 ;
9879 0 : PyObject * obj0 = 0 ;
9880 : unsigned int result;
9881 :
9882 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_is_qualified_get",&obj0)) SWIG_fail;
9883 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9884 0 : if (!SWIG_IsOK(res1)) {
9885 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_is_qualified_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9886 : }
9887 0 : arg1 = (struct _gpgme_key *)(argp1);
9888 : {
9889 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9890 0 : result = (unsigned int) ((arg1)->is_qualified);
9891 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9892 : }
9893 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9894 0 : return resultobj;
9895 : fail:
9896 : return NULL;
9897 : }
9898 :
9899 :
9900 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 0 : PyObject *resultobj = 0;
9902 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9903 : unsigned int arg2 ;
9904 0 : void *argp1 = 0 ;
9905 0 : int res1 = 0 ;
9906 : unsigned int val2 ;
9907 0 : int ecode2 = 0 ;
9908 0 : PyObject * obj0 = 0 ;
9909 0 : PyObject * obj1 = 0 ;
9910 :
9911 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__unused_set",&obj0,&obj1)) SWIG_fail;
9912 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9913 0 : if (!SWIG_IsOK(res1)) {
9914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9915 : }
9916 0 : arg1 = (struct _gpgme_key *)(argp1);
9917 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
9918 0 : if (!SWIG_IsOK(ecode2)) {
9919 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key__unused_set" "', argument " "2"" of type '" "unsigned int""'");
9920 : }
9921 0 : arg2 = (unsigned int)(val2);
9922 : {
9923 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9924 0 : if (arg1) (arg1)->_unused = arg2;
9925 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9926 : }
9927 0 : resultobj = SWIG_Py_Void();
9928 0 : return resultobj;
9929 : fail:
9930 : return NULL;
9931 : }
9932 :
9933 :
9934 0 : SWIGINTERN PyObject *_wrap__gpgme_key__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9935 0 : PyObject *resultobj = 0;
9936 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9937 0 : void *argp1 = 0 ;
9938 0 : int res1 = 0 ;
9939 0 : PyObject * obj0 = 0 ;
9940 : unsigned int result;
9941 :
9942 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__unused_get",&obj0)) SWIG_fail;
9943 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9944 0 : if (!SWIG_IsOK(res1)) {
9945 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__unused_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9946 : }
9947 0 : arg1 = (struct _gpgme_key *)(argp1);
9948 : {
9949 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9950 0 : result = (unsigned int) ((arg1)->_unused);
9951 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9952 : }
9953 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
9954 0 : return resultobj;
9955 : fail:
9956 : return NULL;
9957 : }
9958 :
9959 :
9960 0 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9961 0 : PyObject *resultobj = 0;
9962 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9963 : gpgme_protocol_t arg2 ;
9964 0 : void *argp1 = 0 ;
9965 0 : int res1 = 0 ;
9966 : int val2 ;
9967 0 : int ecode2 = 0 ;
9968 0 : PyObject * obj0 = 0 ;
9969 0 : PyObject * obj1 = 0 ;
9970 :
9971 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_protocol_set",&obj0,&obj1)) SWIG_fail;
9972 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
9973 0 : if (!SWIG_IsOK(res1)) {
9974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
9975 : }
9976 0 : arg1 = (struct _gpgme_key *)(argp1);
9977 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
9978 0 : if (!SWIG_IsOK(ecode2)) {
9979 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_protocol_set" "', argument " "2"" of type '" "gpgme_protocol_t""'");
9980 : }
9981 0 : arg2 = (gpgme_protocol_t)(val2);
9982 : {
9983 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
9984 0 : if (arg1) (arg1)->protocol = arg2;
9985 0 : SWIG_PYTHON_THREAD_END_ALLOW;
9986 : }
9987 0 : resultobj = SWIG_Py_Void();
9988 0 : return resultobj;
9989 : fail:
9990 : return NULL;
9991 : }
9992 :
9993 :
9994 52 : SWIGINTERN PyObject *_wrap__gpgme_key_protocol_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9995 52 : PyObject *resultobj = 0;
9996 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
9997 52 : void *argp1 = 0 ;
9998 52 : int res1 = 0 ;
9999 52 : PyObject * obj0 = 0 ;
10000 : gpgme_protocol_t result;
10001 :
10002 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_protocol_get",&obj0)) SWIG_fail;
10003 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10004 52 : if (!SWIG_IsOK(res1)) {
10005 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_protocol_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10006 : }
10007 52 : arg1 = (struct _gpgme_key *)(argp1);
10008 : {
10009 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10010 52 : result = (gpgme_protocol_t) ((arg1)->protocol);
10011 52 : SWIG_PYTHON_THREAD_END_ALLOW;
10012 : }
10013 104 : resultobj = SWIG_From_int((int)(result));
10014 52 : return resultobj;
10015 : fail:
10016 : return NULL;
10017 : }
10018 :
10019 :
10020 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10021 0 : PyObject *resultobj = 0;
10022 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10023 0 : char *arg2 = (char *) 0 ;
10024 0 : void *argp1 = 0 ;
10025 0 : int res1 = 0 ;
10026 : int res2 ;
10027 0 : char *buf2 = 0 ;
10028 0 : int alloc2 = 0 ;
10029 0 : PyObject * obj0 = 0 ;
10030 0 : PyObject * obj1 = 0 ;
10031 :
10032 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_issuer_serial_set",&obj0,&obj1)) SWIG_fail;
10033 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10034 0 : if (!SWIG_IsOK(res1)) {
10035 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10036 : }
10037 0 : arg1 = (struct _gpgme_key *)(argp1);
10038 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10039 0 : if (!SWIG_IsOK(res2)) {
10040 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_serial_set" "', argument " "2"" of type '" "char *""'");
10041 : }
10042 0 : arg2 = (char *)(buf2);
10043 : {
10044 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10045 0 : if (arg1->issuer_serial) free((char*)arg1->issuer_serial);
10046 0 : if (arg2) {
10047 0 : size_t size = strlen((const char *)(arg2)) + 1;
10048 0 : arg1->issuer_serial = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10049 : } else {
10050 0 : arg1->issuer_serial = 0;
10051 : }
10052 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10053 : }
10054 0 : resultobj = SWIG_Py_Void();
10055 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10056 : return resultobj;
10057 : fail:
10058 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10059 : return NULL;
10060 : }
10061 :
10062 :
10063 52 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_serial_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10064 52 : PyObject *resultobj = 0;
10065 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10066 52 : void *argp1 = 0 ;
10067 52 : int res1 = 0 ;
10068 52 : PyObject * obj0 = 0 ;
10069 52 : char *result = 0 ;
10070 :
10071 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_serial_get",&obj0)) SWIG_fail;
10072 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10073 52 : if (!SWIG_IsOK(res1)) {
10074 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_serial_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10075 : }
10076 52 : arg1 = (struct _gpgme_key *)(argp1);
10077 : {
10078 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10079 52 : result = (char *) ((arg1)->issuer_serial);
10080 52 : SWIG_PYTHON_THREAD_END_ALLOW;
10081 : }
10082 52 : resultobj = SWIG_FromCharPtr((const char *)result);
10083 52 : return resultobj;
10084 : fail:
10085 : return NULL;
10086 : }
10087 :
10088 :
10089 0 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10090 0 : PyObject *resultobj = 0;
10091 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10092 0 : char *arg2 = (char *) 0 ;
10093 0 : void *argp1 = 0 ;
10094 0 : int res1 = 0 ;
10095 : int res2 ;
10096 0 : char *buf2 = 0 ;
10097 0 : int alloc2 = 0 ;
10098 0 : PyObject * obj0 = 0 ;
10099 0 : PyObject * obj1 = 0 ;
10100 :
10101 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_issuer_name_set",&obj0,&obj1)) SWIG_fail;
10102 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10103 0 : if (!SWIG_IsOK(res1)) {
10104 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10105 : }
10106 0 : arg1 = (struct _gpgme_key *)(argp1);
10107 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10108 0 : if (!SWIG_IsOK(res2)) {
10109 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_issuer_name_set" "', argument " "2"" of type '" "char *""'");
10110 : }
10111 0 : arg2 = (char *)(buf2);
10112 : {
10113 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10114 0 : if (arg1->issuer_name) free((char*)arg1->issuer_name);
10115 0 : if (arg2) {
10116 0 : size_t size = strlen((const char *)(arg2)) + 1;
10117 0 : arg1->issuer_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10118 : } else {
10119 0 : arg1->issuer_name = 0;
10120 : }
10121 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10122 : }
10123 0 : resultobj = SWIG_Py_Void();
10124 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10125 : return resultobj;
10126 : fail:
10127 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10128 : return NULL;
10129 : }
10130 :
10131 :
10132 52 : SWIGINTERN PyObject *_wrap__gpgme_key_issuer_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10133 52 : PyObject *resultobj = 0;
10134 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10135 52 : void *argp1 = 0 ;
10136 52 : int res1 = 0 ;
10137 52 : PyObject * obj0 = 0 ;
10138 52 : char *result = 0 ;
10139 :
10140 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_issuer_name_get",&obj0)) SWIG_fail;
10141 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10142 52 : if (!SWIG_IsOK(res1)) {
10143 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_issuer_name_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10144 : }
10145 52 : arg1 = (struct _gpgme_key *)(argp1);
10146 : {
10147 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10148 52 : result = (char *) ((arg1)->issuer_name);
10149 52 : SWIG_PYTHON_THREAD_END_ALLOW;
10150 : }
10151 52 : resultobj = SWIG_FromCharPtr((const char *)result);
10152 52 : return resultobj;
10153 : fail:
10154 : return NULL;
10155 : }
10156 :
10157 :
10158 0 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10159 0 : PyObject *resultobj = 0;
10160 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10161 0 : char *arg2 = (char *) 0 ;
10162 0 : void *argp1 = 0 ;
10163 0 : int res1 = 0 ;
10164 : int res2 ;
10165 0 : char *buf2 = 0 ;
10166 0 : int alloc2 = 0 ;
10167 0 : PyObject * obj0 = 0 ;
10168 0 : PyObject * obj1 = 0 ;
10169 :
10170 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_chain_id_set",&obj0,&obj1)) SWIG_fail;
10171 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10172 0 : if (!SWIG_IsOK(res1)) {
10173 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10174 : }
10175 0 : arg1 = (struct _gpgme_key *)(argp1);
10176 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10177 0 : if (!SWIG_IsOK(res2)) {
10178 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_chain_id_set" "', argument " "2"" of type '" "char *""'");
10179 : }
10180 0 : arg2 = (char *)(buf2);
10181 : {
10182 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10183 0 : if (arg1->chain_id) free((char*)arg1->chain_id);
10184 0 : if (arg2) {
10185 0 : size_t size = strlen((const char *)(arg2)) + 1;
10186 0 : arg1->chain_id = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10187 : } else {
10188 0 : arg1->chain_id = 0;
10189 : }
10190 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10191 : }
10192 0 : resultobj = SWIG_Py_Void();
10193 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10194 : return resultobj;
10195 : fail:
10196 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10197 : return NULL;
10198 : }
10199 :
10200 :
10201 52 : SWIGINTERN PyObject *_wrap__gpgme_key_chain_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10202 52 : PyObject *resultobj = 0;
10203 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10204 52 : void *argp1 = 0 ;
10205 52 : int res1 = 0 ;
10206 52 : PyObject * obj0 = 0 ;
10207 52 : char *result = 0 ;
10208 :
10209 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_chain_id_get",&obj0)) SWIG_fail;
10210 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10211 52 : if (!SWIG_IsOK(res1)) {
10212 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_chain_id_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10213 : }
10214 52 : arg1 = (struct _gpgme_key *)(argp1);
10215 : {
10216 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10217 52 : result = (char *) ((arg1)->chain_id);
10218 52 : SWIG_PYTHON_THREAD_END_ALLOW;
10219 : }
10220 52 : resultobj = SWIG_FromCharPtr((const char *)result);
10221 52 : return resultobj;
10222 : fail:
10223 : return NULL;
10224 : }
10225 :
10226 :
10227 0 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10228 0 : PyObject *resultobj = 0;
10229 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10230 : gpgme_validity_t arg2 ;
10231 0 : void *argp1 = 0 ;
10232 0 : int res1 = 0 ;
10233 : int val2 ;
10234 0 : int ecode2 = 0 ;
10235 0 : PyObject * obj0 = 0 ;
10236 0 : PyObject * obj1 = 0 ;
10237 :
10238 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_owner_trust_set",&obj0,&obj1)) SWIG_fail;
10239 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10240 0 : if (!SWIG_IsOK(res1)) {
10241 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10242 : }
10243 0 : arg1 = (struct _gpgme_key *)(argp1);
10244 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
10245 0 : if (!SWIG_IsOK(ecode2)) {
10246 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_owner_trust_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
10247 : }
10248 0 : arg2 = (gpgme_validity_t)(val2);
10249 : {
10250 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10251 0 : if (arg1) (arg1)->owner_trust = arg2;
10252 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10253 : }
10254 0 : resultobj = SWIG_Py_Void();
10255 0 : return resultobj;
10256 : fail:
10257 : return NULL;
10258 : }
10259 :
10260 :
10261 52 : SWIGINTERN PyObject *_wrap__gpgme_key_owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10262 52 : PyObject *resultobj = 0;
10263 52 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10264 52 : void *argp1 = 0 ;
10265 52 : int res1 = 0 ;
10266 52 : PyObject * obj0 = 0 ;
10267 : gpgme_validity_t result;
10268 :
10269 52 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_owner_trust_get",&obj0)) SWIG_fail;
10270 52 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10271 52 : if (!SWIG_IsOK(res1)) {
10272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10273 : }
10274 52 : arg1 = (struct _gpgme_key *)(argp1);
10275 : {
10276 52 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10277 52 : result = (gpgme_validity_t) ((arg1)->owner_trust);
10278 52 : SWIG_PYTHON_THREAD_END_ALLOW;
10279 : }
10280 104 : resultobj = SWIG_From_int((int)(result));
10281 52 : return resultobj;
10282 : fail:
10283 : return NULL;
10284 : }
10285 :
10286 :
10287 0 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10288 0 : PyObject *resultobj = 0;
10289 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10290 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
10291 0 : void *argp1 = 0 ;
10292 0 : int res1 = 0 ;
10293 0 : void *argp2 = 0 ;
10294 0 : int res2 = 0 ;
10295 0 : PyObject * obj0 = 0 ;
10296 0 : PyObject * obj1 = 0 ;
10297 :
10298 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_subkeys_set",&obj0,&obj1)) SWIG_fail;
10299 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10300 0 : if (!SWIG_IsOK(res1)) {
10301 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10302 : }
10303 0 : arg1 = (struct _gpgme_key *)(argp1);
10304 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
10305 0 : if (!SWIG_IsOK(res2)) {
10306 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_subkeys_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
10307 : }
10308 0 : arg2 = (gpgme_subkey_t)(argp2);
10309 : {
10310 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10311 0 : if (arg1) (arg1)->subkeys = arg2;
10312 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10313 : }
10314 0 : resultobj = SWIG_Py_Void();
10315 0 : return resultobj;
10316 : fail:
10317 : return NULL;
10318 : }
10319 :
10320 :
10321 204 : SWIGINTERN PyObject *_wrap__gpgme_key_subkeys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10322 204 : PyObject *resultobj = 0;
10323 204 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10324 204 : void *argp1 = 0 ;
10325 204 : int res1 = 0 ;
10326 204 : PyObject * obj0 = 0 ;
10327 : gpgme_subkey_t result;
10328 :
10329 204 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_subkeys_get",&obj0)) SWIG_fail;
10330 204 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10331 204 : if (!SWIG_IsOK(res1)) {
10332 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_subkeys_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10333 : }
10334 204 : arg1 = (struct _gpgme_key *)(argp1);
10335 : {
10336 204 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10337 204 : result = (gpgme_subkey_t) ((arg1)->subkeys);
10338 204 : SWIG_PYTHON_THREAD_END_ALLOW;
10339 : }
10340 : {
10341 : int i;
10342 204 : int size = 0;
10343 : gpgme_subkey_t curr;
10344 666 : for (curr = result; curr != NULL; curr = curr->next) {
10345 462 : size++;
10346 : }
10347 204 : resultobj = PyList_New(size);
10348 666 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10349 462 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
10350 462 : PyList_SetItem(resultobj, i, o);
10351 : }
10352 : }
10353 : return resultobj;
10354 : fail:
10355 : return NULL;
10356 : }
10357 :
10358 :
10359 0 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10360 0 : PyObject *resultobj = 0;
10361 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10362 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
10363 0 : void *argp1 = 0 ;
10364 0 : int res1 = 0 ;
10365 0 : void *argp2 = 0 ;
10366 0 : int res2 = 0 ;
10367 0 : PyObject * obj0 = 0 ;
10368 0 : PyObject * obj1 = 0 ;
10369 :
10370 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_uids_set",&obj0,&obj1)) SWIG_fail;
10371 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10372 0 : if (!SWIG_IsOK(res1)) {
10373 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10374 : }
10375 0 : arg1 = (struct _gpgme_key *)(argp1);
10376 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
10377 0 : if (!SWIG_IsOK(res2)) {
10378 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_uids_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
10379 : }
10380 0 : arg2 = (gpgme_user_id_t)(argp2);
10381 : {
10382 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10383 0 : if (arg1) (arg1)->uids = arg2;
10384 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10385 : }
10386 0 : resultobj = SWIG_Py_Void();
10387 0 : return resultobj;
10388 : fail:
10389 : return NULL;
10390 : }
10391 :
10392 :
10393 345 : SWIGINTERN PyObject *_wrap__gpgme_key_uids_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10394 345 : PyObject *resultobj = 0;
10395 345 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10396 345 : void *argp1 = 0 ;
10397 345 : int res1 = 0 ;
10398 345 : PyObject * obj0 = 0 ;
10399 : gpgme_user_id_t result;
10400 :
10401 345 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_uids_get",&obj0)) SWIG_fail;
10402 345 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10403 345 : if (!SWIG_IsOK(res1)) {
10404 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_uids_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10405 : }
10406 345 : arg1 = (struct _gpgme_key *)(argp1);
10407 : {
10408 345 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10409 345 : result = (gpgme_user_id_t) ((arg1)->uids);
10410 345 : SWIG_PYTHON_THREAD_END_ALLOW;
10411 : }
10412 : {
10413 : int i;
10414 345 : int size = 0;
10415 : gpgme_user_id_t curr;
10416 801 : for (curr = result; curr != NULL; curr = curr->next) {
10417 456 : size++;
10418 : }
10419 345 : resultobj = PyList_New(size);
10420 801 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10421 456 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
10422 456 : PyList_SetItem(resultobj, i, o);
10423 : }
10424 : }
10425 : return resultobj;
10426 : fail:
10427 : return NULL;
10428 : }
10429 :
10430 :
10431 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10432 0 : PyObject *resultobj = 0;
10433 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10434 0 : gpgme_subkey_t arg2 = (gpgme_subkey_t) 0 ;
10435 0 : void *argp1 = 0 ;
10436 0 : int res1 = 0 ;
10437 0 : void *argp2 = 0 ;
10438 0 : int res2 = 0 ;
10439 0 : PyObject * obj0 = 0 ;
10440 0 : PyObject * obj1 = 0 ;
10441 :
10442 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__last_subkey_set",&obj0,&obj1)) SWIG_fail;
10443 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10444 0 : if (!SWIG_IsOK(res1)) {
10445 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10446 : }
10447 0 : arg1 = (struct _gpgme_key *)(argp1);
10448 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_subkey, SWIG_POINTER_DISOWN | 0 );
10449 0 : if (!SWIG_IsOK(res2)) {
10450 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_subkey_set" "', argument " "2"" of type '" "gpgme_subkey_t""'");
10451 : }
10452 0 : arg2 = (gpgme_subkey_t)(argp2);
10453 : {
10454 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10455 0 : if (arg1) (arg1)->_last_subkey = arg2;
10456 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10457 : }
10458 0 : resultobj = SWIG_Py_Void();
10459 0 : return resultobj;
10460 : fail:
10461 : return NULL;
10462 : }
10463 :
10464 :
10465 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_subkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10466 0 : PyObject *resultobj = 0;
10467 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10468 0 : void *argp1 = 0 ;
10469 0 : int res1 = 0 ;
10470 0 : PyObject * obj0 = 0 ;
10471 : gpgme_subkey_t result;
10472 :
10473 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_subkey_get",&obj0)) SWIG_fail;
10474 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10475 0 : if (!SWIG_IsOK(res1)) {
10476 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_subkey_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10477 : }
10478 0 : arg1 = (struct _gpgme_key *)(argp1);
10479 : {
10480 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10481 0 : result = (gpgme_subkey_t) ((arg1)->_last_subkey);
10482 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10483 : }
10484 : {
10485 : int i;
10486 0 : int size = 0;
10487 : gpgme_subkey_t curr;
10488 0 : for (curr = result; curr != NULL; curr = curr->next) {
10489 0 : size++;
10490 : }
10491 0 : resultobj = PyList_New(size);
10492 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10493 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_subkey, 0 );
10494 0 : PyList_SetItem(resultobj, i, o);
10495 : }
10496 : }
10497 : return resultobj;
10498 : fail:
10499 : return NULL;
10500 : }
10501 :
10502 :
10503 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10504 0 : PyObject *resultobj = 0;
10505 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10506 0 : gpgme_user_id_t arg2 = (gpgme_user_id_t) 0 ;
10507 0 : void *argp1 = 0 ;
10508 0 : int res1 = 0 ;
10509 0 : void *argp2 = 0 ;
10510 0 : int res2 = 0 ;
10511 0 : PyObject * obj0 = 0 ;
10512 0 : PyObject * obj1 = 0 ;
10513 :
10514 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key__last_uid_set",&obj0,&obj1)) SWIG_fail;
10515 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10516 0 : if (!SWIG_IsOK(res1)) {
10517 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10518 : }
10519 0 : arg1 = (struct _gpgme_key *)(argp1);
10520 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_user_id, SWIG_POINTER_DISOWN | 0 );
10521 0 : if (!SWIG_IsOK(res2)) {
10522 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key__last_uid_set" "', argument " "2"" of type '" "gpgme_user_id_t""'");
10523 : }
10524 0 : arg2 = (gpgme_user_id_t)(argp2);
10525 : {
10526 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10527 0 : if (arg1) (arg1)->_last_uid = arg2;
10528 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10529 : }
10530 0 : resultobj = SWIG_Py_Void();
10531 0 : return resultobj;
10532 : fail:
10533 : return NULL;
10534 : }
10535 :
10536 :
10537 0 : SWIGINTERN PyObject *_wrap__gpgme_key__last_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10538 0 : PyObject *resultobj = 0;
10539 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10540 0 : void *argp1 = 0 ;
10541 0 : int res1 = 0 ;
10542 0 : PyObject * obj0 = 0 ;
10543 : gpgme_user_id_t result;
10544 :
10545 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key__last_uid_get",&obj0)) SWIG_fail;
10546 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10547 0 : if (!SWIG_IsOK(res1)) {
10548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key__last_uid_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10549 : }
10550 0 : arg1 = (struct _gpgme_key *)(argp1);
10551 : {
10552 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10553 0 : result = (gpgme_user_id_t) ((arg1)->_last_uid);
10554 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10555 : }
10556 : {
10557 : int i;
10558 0 : int size = 0;
10559 : gpgme_user_id_t curr;
10560 0 : for (curr = result; curr != NULL; curr = curr->next) {
10561 0 : size++;
10562 : }
10563 0 : resultobj = PyList_New(size);
10564 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
10565 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_user_id, 0 );
10566 0 : PyList_SetItem(resultobj, i, o);
10567 : }
10568 : }
10569 : return resultobj;
10570 : fail:
10571 : return NULL;
10572 : }
10573 :
10574 :
10575 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10576 0 : PyObject *resultobj = 0;
10577 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10578 : gpgme_keylist_mode_t arg2 ;
10579 0 : void *argp1 = 0 ;
10580 0 : int res1 = 0 ;
10581 : unsigned int val2 ;
10582 0 : int ecode2 = 0 ;
10583 0 : PyObject * obj0 = 0 ;
10584 0 : PyObject * obj1 = 0 ;
10585 :
10586 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_keylist_mode_set",&obj0,&obj1)) SWIG_fail;
10587 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10588 0 : if (!SWIG_IsOK(res1)) {
10589 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10590 : }
10591 0 : arg1 = (struct _gpgme_key *)(argp1);
10592 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
10593 0 : if (!SWIG_IsOK(ecode2)) {
10594 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_key_keylist_mode_set" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
10595 : }
10596 0 : arg2 = (gpgme_keylist_mode_t)(val2);
10597 : {
10598 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10599 0 : if (arg1) (arg1)->keylist_mode = arg2;
10600 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10601 : }
10602 0 : resultobj = SWIG_Py_Void();
10603 0 : return resultobj;
10604 : fail:
10605 : return NULL;
10606 : }
10607 :
10608 :
10609 0 : SWIGINTERN PyObject *_wrap__gpgme_key_keylist_mode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10610 0 : PyObject *resultobj = 0;
10611 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10612 0 : void *argp1 = 0 ;
10613 0 : int res1 = 0 ;
10614 0 : PyObject * obj0 = 0 ;
10615 : gpgme_keylist_mode_t result;
10616 :
10617 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_keylist_mode_get",&obj0)) SWIG_fail;
10618 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10619 0 : if (!SWIG_IsOK(res1)) {
10620 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_keylist_mode_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10621 : }
10622 0 : arg1 = (struct _gpgme_key *)(argp1);
10623 : {
10624 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10625 0 : result = (gpgme_keylist_mode_t) ((arg1)->keylist_mode);
10626 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10627 : }
10628 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
10629 0 : return resultobj;
10630 : fail:
10631 : return NULL;
10632 : }
10633 :
10634 :
10635 0 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10636 0 : PyObject *resultobj = 0;
10637 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10638 0 : char *arg2 = (char *) 0 ;
10639 0 : void *argp1 = 0 ;
10640 0 : int res1 = 0 ;
10641 : int res2 ;
10642 0 : char *buf2 = 0 ;
10643 0 : int alloc2 = 0 ;
10644 0 : PyObject * obj0 = 0 ;
10645 0 : PyObject * obj1 = 0 ;
10646 :
10647 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_key_fpr_set",&obj0,&obj1)) SWIG_fail;
10648 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10649 0 : if (!SWIG_IsOK(res1)) {
10650 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10651 : }
10652 0 : arg1 = (struct _gpgme_key *)(argp1);
10653 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10654 0 : if (!SWIG_IsOK(res2)) {
10655 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_key_fpr_set" "', argument " "2"" of type '" "char *""'");
10656 : }
10657 0 : arg2 = (char *)(buf2);
10658 : {
10659 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10660 0 : if (arg1->fpr) free((char*)arg1->fpr);
10661 0 : if (arg2) {
10662 0 : size_t size = strlen((const char *)(arg2)) + 1;
10663 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10664 : } else {
10665 0 : arg1->fpr = 0;
10666 : }
10667 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10668 : }
10669 0 : resultobj = SWIG_Py_Void();
10670 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10671 : return resultobj;
10672 : fail:
10673 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10674 : return NULL;
10675 : }
10676 :
10677 :
10678 49 : SWIGINTERN PyObject *_wrap__gpgme_key_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10679 49 : PyObject *resultobj = 0;
10680 49 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10681 49 : void *argp1 = 0 ;
10682 49 : int res1 = 0 ;
10683 49 : PyObject * obj0 = 0 ;
10684 49 : char *result = 0 ;
10685 :
10686 49 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_key_fpr_get",&obj0)) SWIG_fail;
10687 49 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
10688 49 : if (!SWIG_IsOK(res1)) {
10689 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10690 : }
10691 49 : arg1 = (struct _gpgme_key *)(argp1);
10692 : {
10693 49 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10694 49 : result = (char *) ((arg1)->fpr);
10695 49 : SWIG_PYTHON_THREAD_END_ALLOW;
10696 : }
10697 49 : resultobj = SWIG_FromCharPtr((const char *)result);
10698 49 : return resultobj;
10699 : fail:
10700 : return NULL;
10701 : }
10702 :
10703 :
10704 0 : SWIGINTERN PyObject *_wrap_new__gpgme_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10705 0 : PyObject *resultobj = 0;
10706 0 : struct _gpgme_key *result = 0 ;
10707 :
10708 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_key")) SWIG_fail;
10709 : {
10710 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10711 0 : result = (struct _gpgme_key *)calloc(1, sizeof(struct _gpgme_key));
10712 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10713 : }
10714 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, SWIG_POINTER_NEW | 0 );
10715 0 : return resultobj;
10716 : fail:
10717 : return NULL;
10718 : }
10719 :
10720 :
10721 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10722 0 : PyObject *resultobj = 0;
10723 0 : struct _gpgme_key *arg1 = (struct _gpgme_key *) 0 ;
10724 0 : void *argp1 = 0 ;
10725 0 : int res1 = 0 ;
10726 0 : PyObject * obj0 = 0 ;
10727 :
10728 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_key",&obj0)) SWIG_fail;
10729 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
10730 0 : if (!SWIG_IsOK(res1)) {
10731 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_key" "', argument " "1"" of type '" "struct _gpgme_key *""'");
10732 : }
10733 0 : arg1 = (struct _gpgme_key *)(argp1);
10734 : {
10735 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10736 0 : free((char *) arg1);
10737 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10738 : }
10739 0 : resultobj = SWIG_Py_Void();
10740 0 : return resultobj;
10741 : fail:
10742 : return NULL;
10743 : }
10744 :
10745 :
10746 27 : SWIGINTERN PyObject *_gpgme_key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10747 : PyObject *obj;
10748 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
10749 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_key, SWIG_NewClientData(obj));
10750 27 : return SWIG_Py_Void();
10751 : }
10752 :
10753 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10754 0 : PyObject *resultobj = 0;
10755 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
10756 0 : char *arg2 = (char *) 0 ;
10757 0 : void *argp1 = 0 ;
10758 0 : int res1 = 0 ;
10759 : int res2 ;
10760 0 : char *buf2 = 0 ;
10761 0 : int alloc2 = 0 ;
10762 0 : PyObject * obj0 = 0 ;
10763 0 : PyObject * obj1 = 0 ;
10764 :
10765 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_invalid_key_fpr_set",&obj0,&obj1)) SWIG_fail;
10766 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
10767 0 : if (!SWIG_IsOK(res1)) {
10768 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
10769 : }
10770 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
10771 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
10772 0 : if (!SWIG_IsOK(res2)) {
10773 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_invalid_key_fpr_set" "', argument " "2"" of type '" "char *""'");
10774 : }
10775 0 : arg2 = (char *)(buf2);
10776 : {
10777 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10778 0 : if (arg1->fpr) free((char*)arg1->fpr);
10779 0 : if (arg2) {
10780 0 : size_t size = strlen((const char *)(arg2)) + 1;
10781 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
10782 : } else {
10783 0 : arg1->fpr = 0;
10784 : }
10785 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10786 : }
10787 0 : resultobj = SWIG_Py_Void();
10788 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10789 : return resultobj;
10790 : fail:
10791 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
10792 : return NULL;
10793 : }
10794 :
10795 :
10796 3 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10797 3 : PyObject *resultobj = 0;
10798 3 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
10799 3 : void *argp1 = 0 ;
10800 3 : int res1 = 0 ;
10801 3 : PyObject * obj0 = 0 ;
10802 3 : char *result = 0 ;
10803 :
10804 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_fpr_get",&obj0)) SWIG_fail;
10805 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
10806 3 : if (!SWIG_IsOK(res1)) {
10807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_fpr_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
10808 : }
10809 3 : arg1 = (struct _gpgme_invalid_key *)(argp1);
10810 : {
10811 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10812 3 : result = (char *) ((arg1)->fpr);
10813 3 : SWIG_PYTHON_THREAD_END_ALLOW;
10814 : }
10815 3 : resultobj = SWIG_FromCharPtr((const char *)result);
10816 3 : return resultobj;
10817 : fail:
10818 : return NULL;
10819 : }
10820 :
10821 :
10822 0 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10823 0 : PyObject *resultobj = 0;
10824 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
10825 : gpgme_error_t arg2 ;
10826 0 : void *argp1 = 0 ;
10827 0 : int res1 = 0 ;
10828 0 : PyObject * obj0 = 0 ;
10829 0 : PyObject * obj1 = 0 ;
10830 :
10831 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_invalid_key_reason_set",&obj0,&obj1)) SWIG_fail;
10832 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
10833 0 : if (!SWIG_IsOK(res1)) {
10834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_set" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
10835 : }
10836 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
10837 : {
10838 0 : if (PyLong_Check(obj1))
10839 0 : arg2 = PyLong_AsLong(obj1);
10840 :
10841 0 : else if (PyInt_Check(obj1))
10842 0 : arg2 = PyInt_AsLong(obj1);
10843 :
10844 : else
10845 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
10846 : }
10847 : {
10848 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10849 0 : if (arg1) (arg1)->reason = arg2;
10850 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10851 : }
10852 0 : resultobj = SWIG_Py_Void();
10853 0 : return resultobj;
10854 : fail:
10855 : return NULL;
10856 : }
10857 :
10858 :
10859 3 : SWIGINTERN PyObject *_wrap__gpgme_invalid_key_reason_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10860 3 : PyObject *resultobj = 0;
10861 3 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
10862 3 : void *argp1 = 0 ;
10863 3 : int res1 = 0 ;
10864 3 : PyObject * obj0 = 0 ;
10865 : gpgme_error_t result;
10866 :
10867 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_invalid_key_reason_get",&obj0)) SWIG_fail;
10868 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, 0 | 0 );
10869 3 : if (!SWIG_IsOK(res1)) {
10870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_invalid_key_reason_get" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
10871 : }
10872 3 : arg1 = (struct _gpgme_invalid_key *)(argp1);
10873 : {
10874 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10875 3 : result = ((arg1)->reason);
10876 3 : SWIG_PYTHON_THREAD_END_ALLOW;
10877 : }
10878 : {
10879 3 : resultobj = PyLong_FromLong(result);
10880 : }
10881 3 : return resultobj;
10882 : fail:
10883 : return NULL;
10884 : }
10885 :
10886 :
10887 0 : SWIGINTERN PyObject *_wrap_new__gpgme_invalid_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10888 0 : PyObject *resultobj = 0;
10889 0 : struct _gpgme_invalid_key *result = 0 ;
10890 :
10891 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_invalid_key")) SWIG_fail;
10892 : {
10893 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10894 0 : result = (struct _gpgme_invalid_key *)calloc(1, sizeof(struct _gpgme_invalid_key));
10895 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10896 : }
10897 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_NEW | 0 );
10898 0 : return resultobj;
10899 : fail:
10900 : return NULL;
10901 : }
10902 :
10903 :
10904 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_invalid_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10905 0 : PyObject *resultobj = 0;
10906 0 : struct _gpgme_invalid_key *arg1 = (struct _gpgme_invalid_key *) 0 ;
10907 0 : void *argp1 = 0 ;
10908 0 : int res1 = 0 ;
10909 0 : PyObject * obj0 = 0 ;
10910 :
10911 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_invalid_key",&obj0)) SWIG_fail;
10912 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
10913 0 : if (!SWIG_IsOK(res1)) {
10914 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_invalid_key" "', argument " "1"" of type '" "struct _gpgme_invalid_key *""'");
10915 : }
10916 0 : arg1 = (struct _gpgme_invalid_key *)(argp1);
10917 : {
10918 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10919 0 : free((char *) arg1);
10920 0 : SWIG_PYTHON_THREAD_END_ALLOW;
10921 : }
10922 0 : resultobj = SWIG_Py_Void();
10923 0 : return resultobj;
10924 : fail:
10925 : return NULL;
10926 : }
10927 :
10928 :
10929 27 : SWIGINTERN PyObject *_gpgme_invalid_key_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10930 : PyObject *obj;
10931 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
10932 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_invalid_key, SWIG_NewClientData(obj));
10933 27 : return SWIG_Py_Void();
10934 : }
10935 :
10936 48 : SWIGINTERN PyObject *_wrap_gpgme_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10937 48 : PyObject *resultobj = 0;
10938 48 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
10939 48 : void *argp1 = 0 ;
10940 48 : int res1 = 0 ;
10941 48 : PyObject * obj0 = 0 ;
10942 : gpgme_error_t result;
10943 :
10944 48 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_new",&obj0)) SWIG_fail;
10945 48 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
10946 48 : if (!SWIG_IsOK(res1)) {
10947 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_new" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
10948 : }
10949 48 : arg1 = (gpgme_ctx_t *)(argp1);
10950 : {
10951 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10952 48 : result = gpgme_new(arg1);
10953 48 : SWIG_PYTHON_THREAD_END_ALLOW;
10954 : }
10955 : {
10956 48 : resultobj = PyLong_FromLong(result);
10957 : }
10958 48 : return resultobj;
10959 : fail:
10960 : return NULL;
10961 : }
10962 :
10963 :
10964 44 : SWIGINTERN PyObject *_wrap_gpgme_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10965 44 : PyObject *resultobj = 0;
10966 44 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10967 44 : void *argp1 = 0 ;
10968 44 : int res1 = 0 ;
10969 44 : PyObject * obj0 = 0 ;
10970 :
10971 44 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_release",&obj0)) SWIG_fail;
10972 44 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
10973 44 : if (!SWIG_IsOK(res1)) {
10974 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_release" "', argument " "1"" of type '" "gpgme_ctx_t""'");
10975 : }
10976 44 : arg1 = (gpgme_ctx_t)(argp1);
10977 : {
10978 44 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
10979 44 : gpgme_release(arg1);
10980 44 : SWIG_PYTHON_THREAD_END_ALLOW;
10981 : }
10982 44 : resultobj = SWIG_Py_Void();
10983 44 : return resultobj;
10984 : fail:
10985 : return NULL;
10986 : }
10987 :
10988 :
10989 2 : SWIGINTERN PyObject *_wrap_gpgme_set_ctx_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10990 2 : PyObject *resultobj = 0;
10991 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
10992 2 : char *arg2 = (char *) 0 ;
10993 2 : char *arg3 = (char *) 0 ;
10994 2 : void *argp1 = 0 ;
10995 2 : int res1 = 0 ;
10996 2 : PyObject *encodedInput2 = NULL ;
10997 2 : PyObject *encodedInput3 = NULL ;
10998 2 : PyObject * obj0 = 0 ;
10999 2 : PyObject * obj1 = 0 ;
11000 2 : PyObject * obj2 = 0 ;
11001 : gpgme_error_t result;
11002 :
11003 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_ctx_flag",&obj0,&obj1,&obj2)) SWIG_fail;
11004 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11005 2 : if (!SWIG_IsOK(res1)) {
11006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_ctx_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11007 : }
11008 2 : arg1 = (gpgme_ctx_t)(argp1);
11009 : {
11010 2 : if (obj1 == Py_None)
11011 : arg2 = NULL;
11012 2 : else if (PyUnicode_Check(obj1))
11013 : {
11014 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
11015 2 : if (encodedInput2 == NULL)
11016 : return NULL;
11017 2 : arg2 = PyBytes_AsString(encodedInput2);
11018 : }
11019 0 : else if (PyBytes_Check(obj1))
11020 0 : arg2 = PyBytes_AsString(obj1);
11021 : else {
11022 0 : PyErr_Format(PyExc_TypeError,
11023 : "arg %d: expected str, bytes, or None, got %s",
11024 : 2, obj1->ob_type->tp_name);
11025 0 : return NULL;
11026 : }
11027 : }
11028 : {
11029 2 : if (obj2 == Py_None)
11030 : arg3 = NULL;
11031 2 : else if (PyUnicode_Check(obj2))
11032 : {
11033 2 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
11034 2 : if (encodedInput3 == NULL)
11035 : return NULL;
11036 2 : arg3 = PyBytes_AsString(encodedInput3);
11037 : }
11038 0 : else if (PyBytes_Check(obj2))
11039 0 : arg3 = PyBytes_AsString(obj2);
11040 : else {
11041 0 : PyErr_Format(PyExc_TypeError,
11042 : "arg %d: expected str, bytes, or None, got %s",
11043 : 3, obj2->ob_type->tp_name);
11044 0 : return NULL;
11045 : }
11046 : }
11047 : {
11048 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11049 2 : result = gpgme_set_ctx_flag(arg1,(char const *)arg2,(char const *)arg3);
11050 2 : SWIG_PYTHON_THREAD_END_ALLOW;
11051 : }
11052 : {
11053 2 : resultobj = PyLong_FromLong(result);
11054 : }
11055 : {
11056 2 : Py_XDECREF(encodedInput2);
11057 : }
11058 : {
11059 2 : Py_XDECREF(encodedInput3);
11060 : }
11061 : return resultobj;
11062 : fail:
11063 : {
11064 : Py_XDECREF(encodedInput2);
11065 : }
11066 : {
11067 : Py_XDECREF(encodedInput3);
11068 : }
11069 : return NULL;
11070 : }
11071 :
11072 :
11073 0 : SWIGINTERN PyObject *_wrap_gpgme_get_ctx_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11074 0 : PyObject *resultobj = 0;
11075 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11076 0 : char *arg2 = (char *) 0 ;
11077 0 : void *argp1 = 0 ;
11078 0 : int res1 = 0 ;
11079 0 : PyObject *encodedInput2 = NULL ;
11080 0 : PyObject * obj0 = 0 ;
11081 0 : PyObject * obj1 = 0 ;
11082 0 : char *result = 0 ;
11083 :
11084 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_get_ctx_flag",&obj0,&obj1)) SWIG_fail;
11085 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11086 0 : if (!SWIG_IsOK(res1)) {
11087 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_ctx_flag" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11088 : }
11089 0 : arg1 = (gpgme_ctx_t)(argp1);
11090 : {
11091 0 : if (obj1 == Py_None)
11092 : arg2 = NULL;
11093 0 : else if (PyUnicode_Check(obj1))
11094 : {
11095 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
11096 0 : if (encodedInput2 == NULL)
11097 : return NULL;
11098 0 : arg2 = PyBytes_AsString(encodedInput2);
11099 : }
11100 0 : else if (PyBytes_Check(obj1))
11101 0 : arg2 = PyBytes_AsString(obj1);
11102 : else {
11103 0 : PyErr_Format(PyExc_TypeError,
11104 : "arg %d: expected str, bytes, or None, got %s",
11105 : 2, obj1->ob_type->tp_name);
11106 0 : return NULL;
11107 : }
11108 : }
11109 : {
11110 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11111 0 : result = (char *)gpgme_get_ctx_flag(arg1,(char const *)arg2);
11112 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11113 : }
11114 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11115 : {
11116 0 : Py_XDECREF(encodedInput2);
11117 : }
11118 : return resultobj;
11119 : fail:
11120 : {
11121 : Py_XDECREF(encodedInput2);
11122 : }
11123 : return NULL;
11124 : }
11125 :
11126 :
11127 53 : SWIGINTERN PyObject *_wrap_gpgme_set_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11128 53 : PyObject *resultobj = 0;
11129 53 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11130 : gpgme_protocol_t arg2 ;
11131 53 : void *argp1 = 0 ;
11132 53 : int res1 = 0 ;
11133 : int val2 ;
11134 53 : int ecode2 = 0 ;
11135 53 : PyObject * obj0 = 0 ;
11136 53 : PyObject * obj1 = 0 ;
11137 : gpgme_error_t result;
11138 :
11139 53 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_protocol",&obj0,&obj1)) SWIG_fail;
11140 53 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11141 53 : if (!SWIG_IsOK(res1)) {
11142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11143 : }
11144 53 : arg1 = (gpgme_ctx_t)(argp1);
11145 106 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11146 53 : if (!SWIG_IsOK(ecode2)) {
11147 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
11148 : }
11149 53 : arg2 = (gpgme_protocol_t)(val2);
11150 : {
11151 53 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11152 53 : result = gpgme_set_protocol(arg1,arg2);
11153 53 : SWIG_PYTHON_THREAD_END_ALLOW;
11154 : }
11155 : {
11156 53 : resultobj = PyLong_FromLong(result);
11157 : }
11158 53 : return resultobj;
11159 : fail:
11160 : return NULL;
11161 : }
11162 :
11163 :
11164 55 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11165 55 : PyObject *resultobj = 0;
11166 55 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11167 55 : void *argp1 = 0 ;
11168 55 : int res1 = 0 ;
11169 55 : PyObject * obj0 = 0 ;
11170 : gpgme_protocol_t result;
11171 :
11172 55 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol",&obj0)) SWIG_fail;
11173 55 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11174 55 : if (!SWIG_IsOK(res1)) {
11175 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11176 : }
11177 55 : arg1 = (gpgme_ctx_t)(argp1);
11178 : {
11179 55 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11180 55 : result = (gpgme_protocol_t)gpgme_get_protocol(arg1);
11181 55 : SWIG_PYTHON_THREAD_END_ALLOW;
11182 : }
11183 110 : resultobj = SWIG_From_int((int)(result));
11184 55 : return resultobj;
11185 : fail:
11186 : return NULL;
11187 : }
11188 :
11189 :
11190 0 : SWIGINTERN PyObject *_wrap_gpgme_set_sub_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11191 0 : PyObject *resultobj = 0;
11192 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11193 : gpgme_protocol_t arg2 ;
11194 0 : void *argp1 = 0 ;
11195 0 : int res1 = 0 ;
11196 : int val2 ;
11197 0 : int ecode2 = 0 ;
11198 0 : PyObject * obj0 = 0 ;
11199 0 : PyObject * obj1 = 0 ;
11200 : gpgme_error_t result;
11201 :
11202 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_sub_protocol",&obj0,&obj1)) SWIG_fail;
11203 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11204 0 : if (!SWIG_IsOK(res1)) {
11205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11206 : }
11207 0 : arg1 = (gpgme_ctx_t)(argp1);
11208 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11209 0 : if (!SWIG_IsOK(ecode2)) {
11210 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_sub_protocol" "', argument " "2"" of type '" "gpgme_protocol_t""'");
11211 : }
11212 0 : arg2 = (gpgme_protocol_t)(val2);
11213 : {
11214 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11215 0 : result = gpgme_set_sub_protocol(arg1,arg2);
11216 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11217 : }
11218 : {
11219 0 : resultobj = PyLong_FromLong(result);
11220 : }
11221 0 : return resultobj;
11222 : fail:
11223 : return NULL;
11224 : }
11225 :
11226 :
11227 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sub_protocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11228 0 : PyObject *resultobj = 0;
11229 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11230 0 : void *argp1 = 0 ;
11231 0 : int res1 = 0 ;
11232 0 : PyObject * obj0 = 0 ;
11233 : gpgme_protocol_t result;
11234 :
11235 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_sub_protocol",&obj0)) SWIG_fail;
11236 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11237 0 : if (!SWIG_IsOK(res1)) {
11238 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sub_protocol" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11239 : }
11240 0 : arg1 = (gpgme_ctx_t)(argp1);
11241 : {
11242 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11243 0 : result = (gpgme_protocol_t)gpgme_get_sub_protocol(arg1);
11244 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11245 : }
11246 0 : resultobj = SWIG_From_int((int)(result));
11247 0 : return resultobj;
11248 : fail:
11249 : return NULL;
11250 : }
11251 :
11252 :
11253 0 : SWIGINTERN PyObject *_wrap_gpgme_get_protocol_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11254 0 : PyObject *resultobj = 0;
11255 : gpgme_protocol_t arg1 ;
11256 : int val1 ;
11257 0 : int ecode1 = 0 ;
11258 0 : PyObject * obj0 = 0 ;
11259 0 : char *result = 0 ;
11260 :
11261 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_protocol_name",&obj0)) SWIG_fail;
11262 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
11263 0 : if (!SWIG_IsOK(ecode1)) {
11264 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_get_protocol_name" "', argument " "1"" of type '" "gpgme_protocol_t""'");
11265 : }
11266 0 : arg1 = (gpgme_protocol_t)(val1);
11267 : {
11268 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11269 0 : result = (char *)gpgme_get_protocol_name(arg1);
11270 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11271 : }
11272 0 : resultobj = SWIG_FromCharPtr((const char *)result);
11273 0 : return resultobj;
11274 : fail:
11275 : return NULL;
11276 : }
11277 :
11278 :
11279 61 : SWIGINTERN PyObject *_wrap_gpgme_set_armor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11280 61 : PyObject *resultobj = 0;
11281 61 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11282 : int arg2 ;
11283 61 : void *argp1 = 0 ;
11284 61 : int res1 = 0 ;
11285 : int val2 ;
11286 61 : int ecode2 = 0 ;
11287 61 : PyObject * obj0 = 0 ;
11288 61 : PyObject * obj1 = 0 ;
11289 :
11290 61 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_armor",&obj0,&obj1)) SWIG_fail;
11291 61 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11292 61 : if (!SWIG_IsOK(res1)) {
11293 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11294 : }
11295 61 : arg1 = (gpgme_ctx_t)(argp1);
11296 122 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11297 61 : if (!SWIG_IsOK(ecode2)) {
11298 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_armor" "', argument " "2"" of type '" "int""'");
11299 : }
11300 61 : arg2 = (int)(val2);
11301 : {
11302 61 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11303 61 : gpgme_set_armor(arg1,arg2);
11304 61 : SWIG_PYTHON_THREAD_END_ALLOW;
11305 : }
11306 61 : resultobj = SWIG_Py_Void();
11307 61 : return resultobj;
11308 : fail:
11309 : return NULL;
11310 : }
11311 :
11312 :
11313 0 : SWIGINTERN PyObject *_wrap_gpgme_get_armor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11314 0 : PyObject *resultobj = 0;
11315 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11316 0 : void *argp1 = 0 ;
11317 0 : int res1 = 0 ;
11318 0 : PyObject * obj0 = 0 ;
11319 : int result;
11320 :
11321 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_armor",&obj0)) SWIG_fail;
11322 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11323 0 : if (!SWIG_IsOK(res1)) {
11324 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_armor" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11325 : }
11326 0 : arg1 = (gpgme_ctx_t)(argp1);
11327 : {
11328 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11329 0 : result = (int)gpgme_get_armor(arg1);
11330 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11331 : }
11332 0 : resultobj = SWIG_From_int((int)(result));
11333 0 : return resultobj;
11334 : fail:
11335 : return NULL;
11336 : }
11337 :
11338 :
11339 50 : SWIGINTERN PyObject *_wrap_gpgme_set_textmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11340 50 : PyObject *resultobj = 0;
11341 50 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11342 : int arg2 ;
11343 50 : void *argp1 = 0 ;
11344 50 : int res1 = 0 ;
11345 : int val2 ;
11346 50 : int ecode2 = 0 ;
11347 50 : PyObject * obj0 = 0 ;
11348 50 : PyObject * obj1 = 0 ;
11349 :
11350 50 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_textmode",&obj0,&obj1)) SWIG_fail;
11351 50 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11352 50 : if (!SWIG_IsOK(res1)) {
11353 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11354 : }
11355 50 : arg1 = (gpgme_ctx_t)(argp1);
11356 100 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11357 50 : if (!SWIG_IsOK(ecode2)) {
11358 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_textmode" "', argument " "2"" of type '" "int""'");
11359 : }
11360 50 : arg2 = (int)(val2);
11361 : {
11362 50 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11363 50 : gpgme_set_textmode(arg1,arg2);
11364 50 : SWIG_PYTHON_THREAD_END_ALLOW;
11365 : }
11366 50 : resultobj = SWIG_Py_Void();
11367 50 : return resultobj;
11368 : fail:
11369 : return NULL;
11370 : }
11371 :
11372 :
11373 0 : SWIGINTERN PyObject *_wrap_gpgme_get_textmode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11374 0 : PyObject *resultobj = 0;
11375 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11376 0 : void *argp1 = 0 ;
11377 0 : int res1 = 0 ;
11378 0 : PyObject * obj0 = 0 ;
11379 : int result;
11380 :
11381 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_textmode",&obj0)) SWIG_fail;
11382 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11383 0 : if (!SWIG_IsOK(res1)) {
11384 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_textmode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11385 : }
11386 0 : arg1 = (gpgme_ctx_t)(argp1);
11387 : {
11388 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11389 0 : result = (int)gpgme_get_textmode(arg1);
11390 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11391 : }
11392 0 : resultobj = SWIG_From_int((int)(result));
11393 0 : return resultobj;
11394 : fail:
11395 : return NULL;
11396 : }
11397 :
11398 :
11399 48 : SWIGINTERN PyObject *_wrap_gpgme_set_offline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11400 48 : PyObject *resultobj = 0;
11401 48 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11402 : int arg2 ;
11403 48 : void *argp1 = 0 ;
11404 48 : int res1 = 0 ;
11405 : int val2 ;
11406 48 : int ecode2 = 0 ;
11407 48 : PyObject * obj0 = 0 ;
11408 48 : PyObject * obj1 = 0 ;
11409 :
11410 48 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_offline",&obj0,&obj1)) SWIG_fail;
11411 48 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11412 48 : if (!SWIG_IsOK(res1)) {
11413 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11414 : }
11415 48 : arg1 = (gpgme_ctx_t)(argp1);
11416 96 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11417 48 : if (!SWIG_IsOK(ecode2)) {
11418 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_offline" "', argument " "2"" of type '" "int""'");
11419 : }
11420 48 : arg2 = (int)(val2);
11421 : {
11422 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11423 48 : gpgme_set_offline(arg1,arg2);
11424 48 : SWIG_PYTHON_THREAD_END_ALLOW;
11425 : }
11426 48 : resultobj = SWIG_Py_Void();
11427 48 : return resultobj;
11428 : fail:
11429 : return NULL;
11430 : }
11431 :
11432 :
11433 0 : SWIGINTERN PyObject *_wrap_gpgme_get_offline(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11434 0 : PyObject *resultobj = 0;
11435 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11436 0 : void *argp1 = 0 ;
11437 0 : int res1 = 0 ;
11438 0 : PyObject * obj0 = 0 ;
11439 : int result;
11440 :
11441 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_offline",&obj0)) SWIG_fail;
11442 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11443 0 : if (!SWIG_IsOK(res1)) {
11444 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_offline" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11445 : }
11446 0 : arg1 = (gpgme_ctx_t)(argp1);
11447 : {
11448 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11449 0 : result = (int)gpgme_get_offline(arg1);
11450 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11451 : }
11452 0 : resultobj = SWIG_From_int((int)(result));
11453 0 : return resultobj;
11454 : fail:
11455 : return NULL;
11456 : }
11457 :
11458 :
11459 0 : SWIGINTERN PyObject *_wrap_gpgme_set_include_certs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11460 0 : PyObject *resultobj = 0;
11461 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11462 : int arg2 ;
11463 0 : void *argp1 = 0 ;
11464 0 : int res1 = 0 ;
11465 : int val2 ;
11466 0 : int ecode2 = 0 ;
11467 0 : PyObject * obj0 = 0 ;
11468 0 : PyObject * obj1 = 0 ;
11469 :
11470 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_include_certs",&obj0,&obj1)) SWIG_fail;
11471 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11472 0 : if (!SWIG_IsOK(res1)) {
11473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11474 : }
11475 0 : arg1 = (gpgme_ctx_t)(argp1);
11476 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11477 0 : if (!SWIG_IsOK(ecode2)) {
11478 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_include_certs" "', argument " "2"" of type '" "int""'");
11479 : }
11480 0 : arg2 = (int)(val2);
11481 : {
11482 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11483 0 : gpgme_set_include_certs(arg1,arg2);
11484 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11485 : }
11486 0 : resultobj = SWIG_Py_Void();
11487 0 : return resultobj;
11488 : fail:
11489 : return NULL;
11490 : }
11491 :
11492 :
11493 0 : SWIGINTERN PyObject *_wrap_gpgme_get_include_certs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11494 0 : PyObject *resultobj = 0;
11495 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11496 0 : void *argp1 = 0 ;
11497 0 : int res1 = 0 ;
11498 0 : PyObject * obj0 = 0 ;
11499 : int result;
11500 :
11501 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_include_certs",&obj0)) SWIG_fail;
11502 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11503 0 : if (!SWIG_IsOK(res1)) {
11504 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_include_certs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11505 : }
11506 0 : arg1 = (gpgme_ctx_t)(argp1);
11507 : {
11508 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11509 0 : result = (int)gpgme_get_include_certs(arg1);
11510 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11511 : }
11512 0 : resultobj = SWIG_From_int((int)(result));
11513 0 : return resultobj;
11514 : fail:
11515 : return NULL;
11516 : }
11517 :
11518 :
11519 13 : SWIGINTERN PyObject *_wrap_gpgme_set_keylist_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11520 13 : PyObject *resultobj = 0;
11521 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11522 : gpgme_keylist_mode_t arg2 ;
11523 13 : void *argp1 = 0 ;
11524 13 : int res1 = 0 ;
11525 : unsigned int val2 ;
11526 13 : int ecode2 = 0 ;
11527 13 : PyObject * obj0 = 0 ;
11528 13 : PyObject * obj1 = 0 ;
11529 : gpgme_error_t result;
11530 :
11531 13 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_keylist_mode",&obj0,&obj1)) SWIG_fail;
11532 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11533 13 : if (!SWIG_IsOK(res1)) {
11534 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11535 : }
11536 13 : arg1 = (gpgme_ctx_t)(argp1);
11537 26 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
11538 13 : if (!SWIG_IsOK(ecode2)) {
11539 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_keylist_mode" "', argument " "2"" of type '" "gpgme_keylist_mode_t""'");
11540 : }
11541 13 : arg2 = (gpgme_keylist_mode_t)(val2);
11542 : {
11543 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11544 13 : result = gpgme_set_keylist_mode(arg1,arg2);
11545 13 : SWIG_PYTHON_THREAD_END_ALLOW;
11546 : }
11547 : {
11548 13 : resultobj = PyLong_FromLong(result);
11549 : }
11550 13 : return resultobj;
11551 : fail:
11552 : return NULL;
11553 : }
11554 :
11555 :
11556 0 : SWIGINTERN PyObject *_wrap_gpgme_get_keylist_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11557 0 : PyObject *resultobj = 0;
11558 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11559 0 : void *argp1 = 0 ;
11560 0 : int res1 = 0 ;
11561 0 : PyObject * obj0 = 0 ;
11562 : gpgme_keylist_mode_t result;
11563 :
11564 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_keylist_mode",&obj0)) SWIG_fail;
11565 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11566 0 : if (!SWIG_IsOK(res1)) {
11567 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_keylist_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11568 : }
11569 0 : arg1 = (gpgme_ctx_t)(argp1);
11570 : {
11571 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11572 0 : result = (gpgme_keylist_mode_t)gpgme_get_keylist_mode(arg1);
11573 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11574 : }
11575 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
11576 0 : return resultobj;
11577 : fail:
11578 : return NULL;
11579 : }
11580 :
11581 :
11582 70 : SWIGINTERN PyObject *_wrap_gpgme_set_pinentry_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11583 70 : PyObject *resultobj = 0;
11584 70 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11585 : gpgme_pinentry_mode_t arg2 ;
11586 70 : void *argp1 = 0 ;
11587 70 : int res1 = 0 ;
11588 : int val2 ;
11589 70 : int ecode2 = 0 ;
11590 70 : PyObject * obj0 = 0 ;
11591 70 : PyObject * obj1 = 0 ;
11592 : gpgme_error_t result;
11593 :
11594 70 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_pinentry_mode",&obj0,&obj1)) SWIG_fail;
11595 70 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11596 70 : if (!SWIG_IsOK(res1)) {
11597 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11598 : }
11599 70 : arg1 = (gpgme_ctx_t)(argp1);
11600 140 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11601 70 : if (!SWIG_IsOK(ecode2)) {
11602 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_pinentry_mode" "', argument " "2"" of type '" "gpgme_pinentry_mode_t""'");
11603 : }
11604 70 : arg2 = (gpgme_pinentry_mode_t)(val2);
11605 : {
11606 70 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11607 70 : result = gpgme_set_pinentry_mode(arg1,arg2);
11608 70 : SWIG_PYTHON_THREAD_END_ALLOW;
11609 : }
11610 : {
11611 70 : resultobj = PyLong_FromLong(result);
11612 : }
11613 70 : return resultobj;
11614 : fail:
11615 : return NULL;
11616 : }
11617 :
11618 :
11619 6 : SWIGINTERN PyObject *_wrap_gpgme_get_pinentry_mode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11620 6 : PyObject *resultobj = 0;
11621 6 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11622 6 : void *argp1 = 0 ;
11623 6 : int res1 = 0 ;
11624 6 : PyObject * obj0 = 0 ;
11625 : gpgme_pinentry_mode_t result;
11626 :
11627 6 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_pinentry_mode",&obj0)) SWIG_fail;
11628 6 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11629 6 : if (!SWIG_IsOK(res1)) {
11630 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_pinentry_mode" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11631 : }
11632 6 : arg1 = (gpgme_ctx_t)(argp1);
11633 : {
11634 6 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11635 6 : result = (gpgme_pinentry_mode_t)gpgme_get_pinentry_mode(arg1);
11636 6 : SWIG_PYTHON_THREAD_END_ALLOW;
11637 : }
11638 12 : resultobj = SWIG_From_int((int)(result));
11639 6 : return resultobj;
11640 : fail:
11641 : return NULL;
11642 : }
11643 :
11644 :
11645 0 : SWIGINTERN PyObject *_wrap_gpgme_set_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11646 0 : PyObject *resultobj = 0;
11647 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11648 0 : gpgme_passphrase_cb_t arg2 = (gpgme_passphrase_cb_t) 0 ;
11649 0 : void *arg3 = (void *) 0 ;
11650 0 : void *argp1 = 0 ;
11651 0 : int res1 = 0 ;
11652 : int res3 ;
11653 0 : PyObject * obj0 = 0 ;
11654 0 : PyObject * obj1 = 0 ;
11655 0 : PyObject * obj2 = 0 ;
11656 :
11657 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11658 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11659 0 : if (!SWIG_IsOK(res1)) {
11660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11661 : }
11662 0 : arg1 = (gpgme_ctx_t)(argp1);
11663 : {
11664 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t);
11665 0 : if (!SWIG_IsOK(res)) {
11666 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t""'");
11667 : }
11668 : }
11669 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
11670 0 : if (!SWIG_IsOK(res3)) {
11671 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_passphrase_cb" "', argument " "3"" of type '" "void *""'");
11672 : }
11673 : {
11674 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11675 0 : gpgme_set_passphrase_cb(arg1,arg2,arg3);
11676 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11677 : }
11678 0 : resultobj = SWIG_Py_Void();
11679 0 : return resultobj;
11680 : fail:
11681 : return NULL;
11682 : }
11683 :
11684 :
11685 0 : SWIGINTERN PyObject *_wrap_gpgme_get_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11686 0 : PyObject *resultobj = 0;
11687 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11688 0 : gpgme_passphrase_cb_t *arg2 = (gpgme_passphrase_cb_t *) 0 ;
11689 0 : void **arg3 = (void **) 0 ;
11690 0 : void *argp1 = 0 ;
11691 0 : int res1 = 0 ;
11692 0 : void *argp2 = 0 ;
11693 0 : int res2 = 0 ;
11694 0 : void *argp3 = 0 ;
11695 0 : int res3 = 0 ;
11696 0 : PyObject * obj0 = 0 ;
11697 0 : PyObject * obj1 = 0 ;
11698 0 : PyObject * obj2 = 0 ;
11699 :
11700 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_passphrase_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11701 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11702 0 : if (!SWIG_IsOK(res1)) {
11703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_passphrase_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11704 : }
11705 0 : arg1 = (gpgme_ctx_t)(argp1);
11706 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0 | 0 );
11707 0 : if (!SWIG_IsOK(res2)) {
11708 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_passphrase_cb" "', argument " "2"" of type '" "gpgme_passphrase_cb_t *""'");
11709 : }
11710 0 : arg2 = (gpgme_passphrase_cb_t *)(argp2);
11711 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
11712 0 : if (!SWIG_IsOK(res3)) {
11713 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_passphrase_cb" "', argument " "3"" of type '" "void **""'");
11714 : }
11715 0 : arg3 = (void **)(argp3);
11716 : {
11717 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11718 0 : gpgme_get_passphrase_cb(arg1,arg2,arg3);
11719 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11720 : }
11721 0 : resultobj = SWIG_Py_Void();
11722 0 : return resultobj;
11723 : fail:
11724 : return NULL;
11725 : }
11726 :
11727 :
11728 0 : SWIGINTERN PyObject *_wrap_gpgme_set_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11729 0 : PyObject *resultobj = 0;
11730 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11731 0 : gpgme_progress_cb_t arg2 = (gpgme_progress_cb_t) 0 ;
11732 0 : void *arg3 = (void *) 0 ;
11733 0 : void *argp1 = 0 ;
11734 0 : int res1 = 0 ;
11735 : int res3 ;
11736 0 : PyObject * obj0 = 0 ;
11737 0 : PyObject * obj1 = 0 ;
11738 0 : PyObject * obj2 = 0 ;
11739 :
11740 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11741 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11742 0 : if (!SWIG_IsOK(res1)) {
11743 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11744 : }
11745 0 : arg1 = (gpgme_ctx_t)(argp1);
11746 : {
11747 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_int_int_int__void);
11748 0 : if (!SWIG_IsOK(res)) {
11749 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t""'");
11750 : }
11751 : }
11752 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
11753 0 : if (!SWIG_IsOK(res3)) {
11754 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_progress_cb" "', argument " "3"" of type '" "void *""'");
11755 : }
11756 : {
11757 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11758 0 : gpgme_set_progress_cb(arg1,arg2,arg3);
11759 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11760 : }
11761 0 : resultobj = SWIG_Py_Void();
11762 0 : return resultobj;
11763 : fail:
11764 : return NULL;
11765 : }
11766 :
11767 :
11768 0 : SWIGINTERN PyObject *_wrap_gpgme_get_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11769 0 : PyObject *resultobj = 0;
11770 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11771 0 : gpgme_progress_cb_t *arg2 = (gpgme_progress_cb_t *) 0 ;
11772 0 : void **arg3 = (void **) 0 ;
11773 0 : void *argp1 = 0 ;
11774 0 : int res1 = 0 ;
11775 0 : void *argp2 = 0 ;
11776 0 : int res2 = 0 ;
11777 0 : void *argp3 = 0 ;
11778 0 : int res3 = 0 ;
11779 0 : PyObject * obj0 = 0 ;
11780 0 : PyObject * obj1 = 0 ;
11781 0 : PyObject * obj2 = 0 ;
11782 :
11783 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_progress_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11784 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11785 0 : if (!SWIG_IsOK(res1)) {
11786 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_progress_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11787 : }
11788 0 : arg1 = (gpgme_ctx_t)(argp1);
11789 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_int_int_int__void, 0 | 0 );
11790 0 : if (!SWIG_IsOK(res2)) {
11791 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_progress_cb" "', argument " "2"" of type '" "gpgme_progress_cb_t *""'");
11792 : }
11793 0 : arg2 = (gpgme_progress_cb_t *)(argp2);
11794 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
11795 0 : if (!SWIG_IsOK(res3)) {
11796 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_progress_cb" "', argument " "3"" of type '" "void **""'");
11797 : }
11798 0 : arg3 = (void **)(argp3);
11799 : {
11800 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11801 0 : gpgme_get_progress_cb(arg1,arg2,arg3);
11802 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11803 : }
11804 0 : resultobj = SWIG_Py_Void();
11805 0 : return resultobj;
11806 : fail:
11807 : return NULL;
11808 : }
11809 :
11810 :
11811 0 : SWIGINTERN PyObject *_wrap_gpgme_set_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11812 0 : PyObject *resultobj = 0;
11813 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11814 0 : gpgme_status_cb_t arg2 = (gpgme_status_cb_t) 0 ;
11815 0 : void *arg3 = (void *) 0 ;
11816 0 : void *argp1 = 0 ;
11817 0 : int res1 = 0 ;
11818 : int res3 ;
11819 0 : PyObject * obj0 = 0 ;
11820 0 : PyObject * obj1 = 0 ;
11821 0 : PyObject * obj2 = 0 ;
11822 :
11823 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11824 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11825 0 : if (!SWIG_IsOK(res1)) {
11826 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11827 : }
11828 0 : arg1 = (gpgme_ctx_t)(argp1);
11829 : {
11830 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t);
11831 0 : if (!SWIG_IsOK(res)) {
11832 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_set_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t""'");
11833 : }
11834 : }
11835 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
11836 0 : if (!SWIG_IsOK(res3)) {
11837 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_set_status_cb" "', argument " "3"" of type '" "void *""'");
11838 : }
11839 : {
11840 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11841 0 : gpgme_set_status_cb(arg1,arg2,arg3);
11842 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11843 : }
11844 0 : resultobj = SWIG_Py_Void();
11845 0 : return resultobj;
11846 : fail:
11847 : return NULL;
11848 : }
11849 :
11850 :
11851 0 : SWIGINTERN PyObject *_wrap_gpgme_get_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11852 0 : PyObject *resultobj = 0;
11853 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11854 0 : gpgme_status_cb_t *arg2 = (gpgme_status_cb_t *) 0 ;
11855 0 : void **arg3 = (void **) 0 ;
11856 0 : void *argp1 = 0 ;
11857 0 : int res1 = 0 ;
11858 0 : void *argp2 = 0 ;
11859 0 : int res2 = 0 ;
11860 0 : void *argp3 = 0 ;
11861 0 : int res3 = 0 ;
11862 0 : PyObject * obj0 = 0 ;
11863 0 : PyObject * obj1 = 0 ;
11864 0 : PyObject * obj2 = 0 ;
11865 :
11866 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_get_status_cb",&obj0,&obj1,&obj2)) SWIG_fail;
11867 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11868 0 : if (!SWIG_IsOK(res1)) {
11869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_status_cb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11870 : }
11871 0 : arg1 = (gpgme_ctx_t)(argp1);
11872 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0 | 0 );
11873 0 : if (!SWIG_IsOK(res2)) {
11874 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_status_cb" "', argument " "2"" of type '" "gpgme_status_cb_t *""'");
11875 : }
11876 0 : arg2 = (gpgme_status_cb_t *)(argp2);
11877 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_void, 0 | 0 );
11878 0 : if (!SWIG_IsOK(res3)) {
11879 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_status_cb" "', argument " "3"" of type '" "void **""'");
11880 : }
11881 0 : arg3 = (void **)(argp3);
11882 : {
11883 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11884 0 : gpgme_get_status_cb(arg1,arg2,arg3);
11885 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11886 : }
11887 0 : resultobj = SWIG_Py_Void();
11888 0 : return resultobj;
11889 : fail:
11890 : return NULL;
11891 : }
11892 :
11893 :
11894 0 : SWIGINTERN PyObject *_wrap_gpgme_set_locale(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11895 0 : PyObject *resultobj = 0;
11896 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11897 : int arg2 ;
11898 0 : char *arg3 = (char *) 0 ;
11899 0 : void *argp1 = 0 ;
11900 0 : int res1 = 0 ;
11901 : int val2 ;
11902 0 : int ecode2 = 0 ;
11903 0 : PyObject *encodedInput3 = NULL ;
11904 0 : PyObject * obj0 = 0 ;
11905 0 : PyObject * obj1 = 0 ;
11906 0 : PyObject * obj2 = 0 ;
11907 : gpgme_error_t result;
11908 :
11909 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_locale",&obj0,&obj1,&obj2)) SWIG_fail;
11910 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11911 0 : if (!SWIG_IsOK(res1)) {
11912 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_locale" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11913 : }
11914 0 : arg1 = (gpgme_ctx_t)(argp1);
11915 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
11916 0 : if (!SWIG_IsOK(ecode2)) {
11917 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_set_locale" "', argument " "2"" of type '" "int""'");
11918 : }
11919 0 : arg2 = (int)(val2);
11920 : {
11921 0 : if (obj2 == Py_None)
11922 : arg3 = NULL;
11923 0 : else if (PyUnicode_Check(obj2))
11924 : {
11925 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
11926 0 : if (encodedInput3 == NULL)
11927 : return NULL;
11928 0 : arg3 = PyBytes_AsString(encodedInput3);
11929 : }
11930 0 : else if (PyBytes_Check(obj2))
11931 0 : arg3 = PyBytes_AsString(obj2);
11932 : else {
11933 0 : PyErr_Format(PyExc_TypeError,
11934 : "arg %d: expected str, bytes, or None, got %s",
11935 : 3, obj2->ob_type->tp_name);
11936 0 : return NULL;
11937 : }
11938 : }
11939 : {
11940 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11941 0 : result = gpgme_set_locale(arg1,arg2,(char const *)arg3);
11942 0 : SWIG_PYTHON_THREAD_END_ALLOW;
11943 : }
11944 : {
11945 0 : resultobj = PyLong_FromLong(result);
11946 : }
11947 : {
11948 0 : Py_XDECREF(encodedInput3);
11949 : }
11950 : return resultobj;
11951 : fail:
11952 : {
11953 : Py_XDECREF(encodedInput3);
11954 : }
11955 : return NULL;
11956 : }
11957 :
11958 :
11959 3 : SWIGINTERN PyObject *_wrap_gpgme_ctx_get_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11960 3 : PyObject *resultobj = 0;
11961 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
11962 3 : void *argp1 = 0 ;
11963 3 : int res1 = 0 ;
11964 3 : PyObject * obj0 = 0 ;
11965 : gpgme_engine_info_t result;
11966 :
11967 3 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_get_engine_info",&obj0)) SWIG_fail;
11968 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
11969 3 : if (!SWIG_IsOK(res1)) {
11970 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_get_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
11971 : }
11972 3 : arg1 = (gpgme_ctx_t)(argp1);
11973 : {
11974 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
11975 3 : result = (gpgme_engine_info_t)gpgme_ctx_get_engine_info(arg1);
11976 3 : SWIG_PYTHON_THREAD_END_ALLOW;
11977 : }
11978 : {
11979 : int i;
11980 3 : int size = 0;
11981 : gpgme_engine_info_t curr;
11982 21 : for (curr = result; curr != NULL; curr = curr->next) {
11983 18 : size++;
11984 : }
11985 3 : resultobj = PyList_New(size);
11986 3 : if (resultobj == NULL)
11987 : return NULL; /* raise */
11988 18 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
11989 : PyObject *fragile, *o;
11990 18 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
11991 : 0 );
11992 18 : if (fragile == NULL)
11993 : {
11994 0 : Py_DECREF(resultobj);
11995 : return NULL; /* raise */
11996 : }
11997 18 : o = _gpg_wrap_result(fragile, "EngineInfo");
11998 18 : Py_DECREF(fragile);
11999 18 : if (o == NULL)
12000 : {
12001 0 : Py_DECREF(resultobj);
12002 : return NULL; /* raise */
12003 : }
12004 18 : PyList_SetItem(resultobj, i, o);
12005 : }
12006 : }
12007 : return resultobj;
12008 : fail:
12009 : return NULL;
12010 : }
12011 :
12012 :
12013 53 : SWIGINTERN PyObject *_wrap_gpgme_ctx_set_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12014 53 : PyObject *resultobj = 0;
12015 53 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12016 : gpgme_protocol_t arg2 ;
12017 53 : char *arg3 = (char *) 0 ;
12018 53 : char *arg4 = (char *) 0 ;
12019 53 : void *argp1 = 0 ;
12020 53 : int res1 = 0 ;
12021 : int val2 ;
12022 53 : int ecode2 = 0 ;
12023 53 : PyObject *encodedInput3 = NULL ;
12024 53 : PyObject *encodedInput4 = NULL ;
12025 53 : PyObject * obj0 = 0 ;
12026 53 : PyObject * obj1 = 0 ;
12027 53 : PyObject * obj2 = 0 ;
12028 53 : PyObject * obj3 = 0 ;
12029 : gpgme_error_t result;
12030 :
12031 53 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_ctx_set_engine_info",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12032 53 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12033 53 : if (!SWIG_IsOK(res1)) {
12034 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_set_engine_info" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12035 : }
12036 53 : arg1 = (gpgme_ctx_t)(argp1);
12037 106 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12038 53 : if (!SWIG_IsOK(ecode2)) {
12039 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_ctx_set_engine_info" "', argument " "2"" of type '" "gpgme_protocol_t""'");
12040 : }
12041 53 : arg2 = (gpgme_protocol_t)(val2);
12042 : {
12043 53 : if (obj2 == Py_None)
12044 : arg3 = NULL;
12045 5 : else if (PyUnicode_Check(obj2))
12046 : {
12047 5 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
12048 5 : if (encodedInput3 == NULL)
12049 : return NULL;
12050 5 : arg3 = PyBytes_AsString(encodedInput3);
12051 : }
12052 0 : else if (PyBytes_Check(obj2))
12053 0 : arg3 = PyBytes_AsString(obj2);
12054 : else {
12055 0 : PyErr_Format(PyExc_TypeError,
12056 : "arg %d: expected str, bytes, or None, got %s",
12057 : 3, obj2->ob_type->tp_name);
12058 0 : return NULL;
12059 : }
12060 : }
12061 : {
12062 53 : if (obj3 == Py_None)
12063 : arg4 = NULL;
12064 5 : else if (PyUnicode_Check(obj3))
12065 : {
12066 0 : encodedInput4 = PyUnicode_AsUTF8String(obj3);
12067 0 : if (encodedInput4 == NULL)
12068 : return NULL;
12069 0 : arg4 = PyBytes_AsString(encodedInput4);
12070 : }
12071 5 : else if (PyBytes_Check(obj3))
12072 5 : arg4 = PyBytes_AsString(obj3);
12073 : else {
12074 0 : PyErr_Format(PyExc_TypeError,
12075 : "arg %d: expected str, bytes, or None, got %s",
12076 : 4, obj3->ob_type->tp_name);
12077 0 : return NULL;
12078 : }
12079 : }
12080 : {
12081 53 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12082 53 : result = gpgme_ctx_set_engine_info(arg1,arg2,(char const *)arg3,(char const *)arg4);
12083 53 : SWIG_PYTHON_THREAD_END_ALLOW;
12084 : }
12085 : {
12086 53 : resultobj = PyLong_FromLong(result);
12087 : }
12088 : {
12089 53 : Py_XDECREF(encodedInput3);
12090 : }
12091 : {
12092 53 : Py_XDECREF(encodedInput4);
12093 : }
12094 : return resultobj;
12095 : fail:
12096 : {
12097 : Py_XDECREF(encodedInput3);
12098 : }
12099 : {
12100 : Py_XDECREF(encodedInput4);
12101 : }
12102 : return NULL;
12103 : }
12104 :
12105 :
12106 55 : SWIGINTERN PyObject *_wrap_gpgme_signers_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12107 55 : PyObject *resultobj = 0;
12108 55 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12109 55 : void *argp1 = 0 ;
12110 55 : int res1 = 0 ;
12111 55 : PyObject * obj0 = 0 ;
12112 :
12113 55 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_clear",&obj0)) SWIG_fail;
12114 55 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12115 55 : if (!SWIG_IsOK(res1)) {
12116 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12117 : }
12118 55 : arg1 = (gpgme_ctx_t)(argp1);
12119 : {
12120 55 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12121 55 : gpgme_signers_clear(arg1);
12122 55 : SWIG_PYTHON_THREAD_END_ALLOW;
12123 : }
12124 55 : resultobj = SWIG_Py_Void();
12125 55 : return resultobj;
12126 : fail:
12127 : return NULL;
12128 : }
12129 :
12130 :
12131 12 : SWIGINTERN PyObject *_wrap_gpgme_signers_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12132 12 : PyObject *resultobj = 0;
12133 12 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12134 12 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
12135 12 : void *argp1 = 0 ;
12136 12 : int res1 = 0 ;
12137 12 : void *argp2 = 0 ;
12138 12 : int res2 = 0 ;
12139 12 : PyObject * obj0 = 0 ;
12140 12 : PyObject * obj1 = 0 ;
12141 : gpgme_error_t result;
12142 :
12143 12 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_add",&obj0,&obj1)) SWIG_fail;
12144 12 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12145 12 : if (!SWIG_IsOK(res1)) {
12146 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12147 : }
12148 12 : arg1 = (gpgme_ctx_t)(argp1);
12149 12 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
12150 12 : if (!SWIG_IsOK(res2)) {
12151 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_signers_add" "', argument " "2"" of type '" "gpgme_key_t const""'");
12152 : }
12153 12 : arg2 = (gpgme_key_t)(argp2);
12154 : {
12155 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12156 12 : result = gpgme_signers_add(arg1,arg2);
12157 12 : SWIG_PYTHON_THREAD_END_ALLOW;
12158 : }
12159 : {
12160 12 : resultobj = PyLong_FromLong(result);
12161 : }
12162 12 : return resultobj;
12163 : fail:
12164 : return NULL;
12165 : }
12166 :
12167 :
12168 55 : SWIGINTERN PyObject *_wrap_gpgme_signers_count(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12169 55 : PyObject *resultobj = 0;
12170 55 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
12171 55 : void *argp1 = 0 ;
12172 55 : int res1 = 0 ;
12173 55 : PyObject * obj0 = 0 ;
12174 : unsigned int result;
12175 :
12176 55 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_signers_count",&obj0)) SWIG_fail;
12177 55 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12178 55 : if (!SWIG_IsOK(res1)) {
12179 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_count" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
12180 : }
12181 55 : arg1 = (gpgme_ctx_t)(argp1);
12182 : {
12183 55 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12184 55 : result = (unsigned int)gpgme_signers_count(arg1);
12185 55 : SWIG_PYTHON_THREAD_END_ALLOW;
12186 : }
12187 55 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
12188 55 : return resultobj;
12189 : fail:
12190 : return NULL;
12191 : }
12192 :
12193 :
12194 5 : SWIGINTERN PyObject *_wrap_gpgme_signers_enum(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12195 5 : PyObject *resultobj = 0;
12196 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) (gpgme_ctx_t)0 ;
12197 : int arg2 ;
12198 5 : void *argp1 = 0 ;
12199 5 : int res1 = 0 ;
12200 : int val2 ;
12201 5 : int ecode2 = 0 ;
12202 5 : PyObject * obj0 = 0 ;
12203 5 : PyObject * obj1 = 0 ;
12204 : gpgme_key_t result;
12205 :
12206 5 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_signers_enum",&obj0,&obj1)) SWIG_fail;
12207 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12208 5 : if (!SWIG_IsOK(res1)) {
12209 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_signers_enum" "', argument " "1"" of type '" "gpgme_ctx_t const""'");
12210 : }
12211 5 : arg1 = (gpgme_ctx_t)(argp1);
12212 10 : ecode2 = SWIG_AsVal_int(obj1, &val2);
12213 5 : if (!SWIG_IsOK(ecode2)) {
12214 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_signers_enum" "', argument " "2"" of type '" "int""'");
12215 : }
12216 5 : arg2 = (int)(val2);
12217 : {
12218 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12219 5 : result = (gpgme_key_t)gpgme_signers_enum(arg1,arg2);
12220 5 : SWIG_PYTHON_THREAD_END_ALLOW;
12221 : }
12222 5 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
12223 5 : return resultobj;
12224 : fail:
12225 : return NULL;
12226 : }
12227 :
12228 :
12229 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12230 0 : PyObject *resultobj = 0;
12231 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12232 0 : void *argp1 = 0 ;
12233 0 : int res1 = 0 ;
12234 0 : PyObject * obj0 = 0 ;
12235 :
12236 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_clear",&obj0)) SWIG_fail;
12237 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12238 0 : if (!SWIG_IsOK(res1)) {
12239 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_clear" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12240 : }
12241 0 : arg1 = (gpgme_ctx_t)(argp1);
12242 : {
12243 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12244 0 : gpgme_sig_notation_clear(arg1);
12245 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12246 : }
12247 0 : resultobj = SWIG_Py_Void();
12248 0 : return resultobj;
12249 : fail:
12250 : return NULL;
12251 : }
12252 :
12253 :
12254 3 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_add(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12255 3 : PyObject *resultobj = 0;
12256 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12257 3 : char *arg2 = (char *) 0 ;
12258 3 : char *arg3 = (char *) 0 ;
12259 : gpgme_sig_notation_flags_t arg4 ;
12260 3 : void *argp1 = 0 ;
12261 3 : int res1 = 0 ;
12262 3 : PyObject *encodedInput2 = NULL ;
12263 3 : PyObject *encodedInput3 = NULL ;
12264 : unsigned int val4 ;
12265 3 : int ecode4 = 0 ;
12266 3 : PyObject * obj0 = 0 ;
12267 3 : PyObject * obj1 = 0 ;
12268 3 : PyObject * obj2 = 0 ;
12269 3 : PyObject * obj3 = 0 ;
12270 : gpgme_error_t result;
12271 :
12272 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_sig_notation_add",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12273 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12274 3 : if (!SWIG_IsOK(res1)) {
12275 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_add" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12276 : }
12277 3 : arg1 = (gpgme_ctx_t)(argp1);
12278 : {
12279 3 : if (obj1 == Py_None)
12280 : arg2 = NULL;
12281 2 : else if (PyUnicode_Check(obj1))
12282 : {
12283 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
12284 2 : if (encodedInput2 == NULL)
12285 : return NULL;
12286 2 : arg2 = PyBytes_AsString(encodedInput2);
12287 : }
12288 0 : else if (PyBytes_Check(obj1))
12289 0 : arg2 = PyBytes_AsString(obj1);
12290 : else {
12291 0 : PyErr_Format(PyExc_TypeError,
12292 : "arg %d: expected str, bytes, or None, got %s",
12293 : 2, obj1->ob_type->tp_name);
12294 0 : return NULL;
12295 : }
12296 : }
12297 : {
12298 3 : if (obj2 == Py_None)
12299 : arg3 = NULL;
12300 3 : else if (PyUnicode_Check(obj2))
12301 : {
12302 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
12303 3 : if (encodedInput3 == NULL)
12304 : return NULL;
12305 3 : arg3 = PyBytes_AsString(encodedInput3);
12306 : }
12307 0 : else if (PyBytes_Check(obj2))
12308 0 : arg3 = PyBytes_AsString(obj2);
12309 : else {
12310 0 : PyErr_Format(PyExc_TypeError,
12311 : "arg %d: expected str, bytes, or None, got %s",
12312 : 3, obj2->ob_type->tp_name);
12313 0 : return NULL;
12314 : }
12315 : }
12316 6 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
12317 3 : if (!SWIG_IsOK(ecode4)) {
12318 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_sig_notation_add" "', argument " "4"" of type '" "gpgme_sig_notation_flags_t""'");
12319 : }
12320 3 : arg4 = (gpgme_sig_notation_flags_t)(val4);
12321 : {
12322 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12323 3 : result = gpgme_sig_notation_add(arg1,(char const *)arg2,(char const *)arg3,arg4);
12324 3 : SWIG_PYTHON_THREAD_END_ALLOW;
12325 : }
12326 : {
12327 3 : resultobj = PyLong_FromLong(result);
12328 : }
12329 : {
12330 3 : Py_XDECREF(encodedInput2);
12331 : }
12332 : {
12333 3 : Py_XDECREF(encodedInput3);
12334 : }
12335 : return resultobj;
12336 : fail:
12337 : {
12338 0 : Py_XDECREF(encodedInput2);
12339 : }
12340 : {
12341 0 : Py_XDECREF(encodedInput3);
12342 : }
12343 : return NULL;
12344 : }
12345 :
12346 :
12347 0 : SWIGINTERN PyObject *_wrap_gpgme_sig_notation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12348 0 : PyObject *resultobj = 0;
12349 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12350 0 : void *argp1 = 0 ;
12351 0 : int res1 = 0 ;
12352 0 : PyObject * obj0 = 0 ;
12353 : gpgme_sig_notation_t result;
12354 :
12355 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_sig_notation_get",&obj0)) SWIG_fail;
12356 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12357 0 : if (!SWIG_IsOK(res1)) {
12358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_sig_notation_get" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12359 : }
12360 0 : arg1 = (gpgme_ctx_t)(argp1);
12361 : {
12362 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12363 0 : result = (gpgme_sig_notation_t)gpgme_sig_notation_get(arg1);
12364 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12365 : }
12366 : {
12367 : int i;
12368 0 : int size = 0;
12369 : gpgme_sig_notation_t curr;
12370 0 : for (curr = result; curr != NULL; curr = curr->next) {
12371 0 : size++;
12372 : }
12373 0 : resultobj = PyList_New(size);
12374 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
12375 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
12376 0 : PyList_SetItem(resultobj, i, o);
12377 : }
12378 : }
12379 : return resultobj;
12380 : fail:
12381 : return NULL;
12382 : }
12383 :
12384 :
12385 0 : SWIGINTERN PyObject *_wrap_gpgme_set_sender(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12386 0 : PyObject *resultobj = 0;
12387 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12388 0 : char *arg2 = (char *) 0 ;
12389 0 : void *argp1 = 0 ;
12390 0 : int res1 = 0 ;
12391 0 : PyObject *encodedInput2 = NULL ;
12392 0 : PyObject * obj0 = 0 ;
12393 0 : PyObject * obj1 = 0 ;
12394 : gpgme_error_t result;
12395 :
12396 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_sender",&obj0,&obj1)) SWIG_fail;
12397 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12398 0 : if (!SWIG_IsOK(res1)) {
12399 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_sender" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12400 : }
12401 0 : arg1 = (gpgme_ctx_t)(argp1);
12402 : {
12403 0 : if (obj1 == Py_None)
12404 : arg2 = NULL;
12405 0 : else if (PyUnicode_Check(obj1))
12406 : {
12407 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
12408 0 : if (encodedInput2 == NULL)
12409 : return NULL;
12410 0 : arg2 = PyBytes_AsString(encodedInput2);
12411 : }
12412 0 : else if (PyBytes_Check(obj1))
12413 0 : arg2 = PyBytes_AsString(obj1);
12414 : else {
12415 0 : PyErr_Format(PyExc_TypeError,
12416 : "arg %d: expected str, bytes, or None, got %s",
12417 : 2, obj1->ob_type->tp_name);
12418 0 : return NULL;
12419 : }
12420 : }
12421 : {
12422 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12423 0 : result = gpgme_set_sender(arg1,(char const *)arg2);
12424 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12425 : }
12426 : {
12427 0 : resultobj = PyLong_FromLong(result);
12428 : }
12429 : {
12430 0 : Py_XDECREF(encodedInput2);
12431 : }
12432 : return resultobj;
12433 : fail:
12434 : {
12435 : Py_XDECREF(encodedInput2);
12436 : }
12437 : return NULL;
12438 : }
12439 :
12440 :
12441 0 : SWIGINTERN PyObject *_wrap_gpgme_get_sender(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12442 0 : PyObject *resultobj = 0;
12443 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12444 0 : void *argp1 = 0 ;
12445 0 : int res1 = 0 ;
12446 0 : PyObject * obj0 = 0 ;
12447 0 : char *result = 0 ;
12448 :
12449 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_sender",&obj0)) SWIG_fail;
12450 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
12451 0 : if (!SWIG_IsOK(res1)) {
12452 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_sender" "', argument " "1"" of type '" "gpgme_ctx_t""'");
12453 : }
12454 0 : arg1 = (gpgme_ctx_t)(argp1);
12455 : {
12456 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12457 0 : result = (char *)gpgme_get_sender(arg1);
12458 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12459 : }
12460 0 : resultobj = SWIG_FromCharPtr((const char *)result);
12461 0 : return resultobj;
12462 : fail:
12463 : return NULL;
12464 : }
12465 :
12466 :
12467 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12468 0 : PyObject *resultobj = 0;
12469 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12470 : gpgme_error_t arg2 ;
12471 0 : void *argp1 = 0 ;
12472 0 : int res1 = 0 ;
12473 0 : PyObject * obj0 = 0 ;
12474 0 : PyObject * obj1 = 0 ;
12475 :
12476 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_event_done_data_err_set",&obj0,&obj1)) SWIG_fail;
12477 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12478 0 : if (!SWIG_IsOK(res1)) {
12479 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_err_set" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
12480 : }
12481 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12482 : {
12483 0 : if (PyLong_Check(obj1))
12484 0 : arg2 = PyLong_AsLong(obj1);
12485 :
12486 0 : else if (PyInt_Check(obj1))
12487 0 : arg2 = PyInt_AsLong(obj1);
12488 :
12489 : else
12490 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
12491 : }
12492 : {
12493 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12494 0 : if (arg1) (arg1)->err = arg2;
12495 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12496 : }
12497 0 : resultobj = SWIG_Py_Void();
12498 0 : return resultobj;
12499 : fail:
12500 : return NULL;
12501 : }
12502 :
12503 :
12504 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12505 0 : PyObject *resultobj = 0;
12506 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12507 0 : void *argp1 = 0 ;
12508 0 : int res1 = 0 ;
12509 0 : PyObject * obj0 = 0 ;
12510 : gpgme_error_t result;
12511 :
12512 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_err_get",&obj0)) SWIG_fail;
12513 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12514 0 : if (!SWIG_IsOK(res1)) {
12515 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_err_get" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
12516 : }
12517 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12518 : {
12519 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12520 0 : result = ((arg1)->err);
12521 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12522 : }
12523 : {
12524 0 : resultobj = PyLong_FromLong(result);
12525 : }
12526 0 : return resultobj;
12527 : fail:
12528 : return NULL;
12529 : }
12530 :
12531 :
12532 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12533 0 : PyObject *resultobj = 0;
12534 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12535 : gpgme_error_t arg2 ;
12536 0 : void *argp1 = 0 ;
12537 0 : int res1 = 0 ;
12538 0 : PyObject * obj0 = 0 ;
12539 0 : PyObject * obj1 = 0 ;
12540 :
12541 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_event_done_data_op_err_set",&obj0,&obj1)) SWIG_fail;
12542 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12543 0 : if (!SWIG_IsOK(res1)) {
12544 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_op_err_set" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
12545 : }
12546 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12547 : {
12548 0 : if (PyLong_Check(obj1))
12549 0 : arg2 = PyLong_AsLong(obj1);
12550 :
12551 0 : else if (PyInt_Check(obj1))
12552 0 : arg2 = PyInt_AsLong(obj1);
12553 :
12554 : else
12555 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
12556 : }
12557 : {
12558 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12559 0 : if (arg1) (arg1)->op_err = arg2;
12560 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12561 : }
12562 0 : resultobj = SWIG_Py_Void();
12563 0 : return resultobj;
12564 : fail:
12565 : return NULL;
12566 : }
12567 :
12568 :
12569 0 : SWIGINTERN PyObject *_wrap_gpgme_io_event_done_data_op_err_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12570 0 : PyObject *resultobj = 0;
12571 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12572 0 : void *argp1 = 0 ;
12573 0 : int res1 = 0 ;
12574 0 : PyObject * obj0 = 0 ;
12575 : gpgme_error_t result;
12576 :
12577 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_event_done_data_op_err_get",&obj0)) SWIG_fail;
12578 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, 0 | 0 );
12579 0 : if (!SWIG_IsOK(res1)) {
12580 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_event_done_data_op_err_get" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
12581 : }
12582 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12583 : {
12584 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12585 0 : result = ((arg1)->op_err);
12586 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12587 : }
12588 : {
12589 0 : resultobj = PyLong_FromLong(result);
12590 : }
12591 0 : return resultobj;
12592 : fail:
12593 : return NULL;
12594 : }
12595 :
12596 :
12597 0 : SWIGINTERN PyObject *_wrap_new_gpgme_io_event_done_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12598 0 : PyObject *resultobj = 0;
12599 0 : struct gpgme_io_event_done_data *result = 0 ;
12600 :
12601 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_io_event_done_data")) SWIG_fail;
12602 : {
12603 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12604 0 : result = (struct gpgme_io_event_done_data *)calloc(1, sizeof(struct gpgme_io_event_done_data));
12605 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12606 : }
12607 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_event_done_data, SWIG_POINTER_NEW | 0 );
12608 0 : return resultobj;
12609 : fail:
12610 : return NULL;
12611 : }
12612 :
12613 :
12614 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_event_done_data(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12615 0 : PyObject *resultobj = 0;
12616 0 : struct gpgme_io_event_done_data *arg1 = (struct gpgme_io_event_done_data *) 0 ;
12617 0 : void *argp1 = 0 ;
12618 0 : int res1 = 0 ;
12619 0 : PyObject * obj0 = 0 ;
12620 :
12621 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_io_event_done_data",&obj0)) SWIG_fail;
12622 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_event_done_data, SWIG_POINTER_DISOWN | 0 );
12623 0 : if (!SWIG_IsOK(res1)) {
12624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_io_event_done_data" "', argument " "1"" of type '" "struct gpgme_io_event_done_data *""'");
12625 : }
12626 0 : arg1 = (struct gpgme_io_event_done_data *)(argp1);
12627 : {
12628 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12629 0 : free((char *) arg1);
12630 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12631 : }
12632 0 : resultobj = SWIG_Py_Void();
12633 0 : return resultobj;
12634 : fail:
12635 : return NULL;
12636 : }
12637 :
12638 :
12639 27 : SWIGINTERN PyObject *gpgme_io_event_done_data_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12640 : PyObject *obj;
12641 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12642 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_io_event_done_data, SWIG_NewClientData(obj));
12643 27 : return SWIG_Py_Void();
12644 : }
12645 :
12646 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12647 0 : PyObject *resultobj = 0;
12648 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12649 0 : gpgme_register_io_cb_t arg2 = (gpgme_register_io_cb_t) 0 ;
12650 0 : void *argp1 = 0 ;
12651 0 : int res1 = 0 ;
12652 0 : PyObject * obj0 = 0 ;
12653 0 : PyObject * obj1 = 0 ;
12654 :
12655 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_add_set",&obj0,&obj1)) SWIG_fail;
12656 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12657 0 : if (!SWIG_IsOK(res1)) {
12658 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12659 : }
12660 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12661 : {
12662 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t);
12663 0 : if (!SWIG_IsOK(res)) {
12664 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_add_set" "', argument " "2"" of type '" "gpgme_register_io_cb_t""'");
12665 : }
12666 : }
12667 : {
12668 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12669 0 : if (arg1) (arg1)->add = arg2;
12670 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12671 : }
12672 0 : resultobj = SWIG_Py_Void();
12673 0 : return resultobj;
12674 : fail:
12675 : return NULL;
12676 : }
12677 :
12678 :
12679 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12680 0 : PyObject *resultobj = 0;
12681 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12682 0 : void *argp1 = 0 ;
12683 0 : int res1 = 0 ;
12684 0 : PyObject * obj0 = 0 ;
12685 : gpgme_register_io_cb_t result;
12686 :
12687 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_get",&obj0)) SWIG_fail;
12688 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12689 0 : if (!SWIG_IsOK(res1)) {
12690 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12691 : }
12692 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12693 : {
12694 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12695 0 : result = (gpgme_register_io_cb_t) ((arg1)->add);
12696 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12697 : }
12698 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t);
12699 0 : return resultobj;
12700 : fail:
12701 : return NULL;
12702 : }
12703 :
12704 :
12705 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12706 0 : PyObject *resultobj = 0;
12707 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12708 0 : void *arg2 = (void *) 0 ;
12709 0 : void *argp1 = 0 ;
12710 0 : int res1 = 0 ;
12711 : int res2 ;
12712 0 : PyObject * obj0 = 0 ;
12713 0 : PyObject * obj1 = 0 ;
12714 :
12715 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_add_priv_set",&obj0,&obj1)) SWIG_fail;
12716 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12717 0 : if (!SWIG_IsOK(res1)) {
12718 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12719 : }
12720 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12721 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
12722 0 : if (!SWIG_IsOK(res2)) {
12723 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_add_priv_set" "', argument " "2"" of type '" "void *""'");
12724 : }
12725 : {
12726 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12727 0 : if (arg1) (arg1)->add_priv = arg2;
12728 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12729 : }
12730 0 : resultobj = SWIG_Py_Void();
12731 0 : return resultobj;
12732 : fail:
12733 : return NULL;
12734 : }
12735 :
12736 :
12737 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_add_priv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 0 : PyObject *resultobj = 0;
12739 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12740 0 : void *argp1 = 0 ;
12741 0 : int res1 = 0 ;
12742 0 : PyObject * obj0 = 0 ;
12743 0 : void *result = 0 ;
12744 :
12745 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_add_priv_get",&obj0)) SWIG_fail;
12746 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12747 0 : if (!SWIG_IsOK(res1)) {
12748 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_add_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12749 : }
12750 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12751 : {
12752 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12753 0 : result = (void *) ((arg1)->add_priv);
12754 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12755 : }
12756 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
12757 0 : return resultobj;
12758 : fail:
12759 : return NULL;
12760 : }
12761 :
12762 :
12763 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12764 0 : PyObject *resultobj = 0;
12765 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12766 0 : gpgme_remove_io_cb_t arg2 = (gpgme_remove_io_cb_t) 0 ;
12767 0 : void *argp1 = 0 ;
12768 0 : int res1 = 0 ;
12769 0 : PyObject * obj0 = 0 ;
12770 0 : PyObject * obj1 = 0 ;
12771 :
12772 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_remove_set",&obj0,&obj1)) SWIG_fail;
12773 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12774 0 : if (!SWIG_IsOK(res1)) {
12775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12776 : }
12777 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12778 : {
12779 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
12780 0 : if (!SWIG_IsOK(res)) {
12781 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_remove_set" "', argument " "2"" of type '" "gpgme_remove_io_cb_t""'");
12782 : }
12783 : }
12784 : {
12785 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12786 0 : if (arg1) (arg1)->remove = arg2;
12787 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12788 : }
12789 0 : resultobj = SWIG_Py_Void();
12790 0 : return resultobj;
12791 : fail:
12792 : return NULL;
12793 : }
12794 :
12795 :
12796 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_remove_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 0 : PyObject *resultobj = 0;
12798 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12799 0 : void *argp1 = 0 ;
12800 0 : int res1 = 0 ;
12801 0 : PyObject * obj0 = 0 ;
12802 : gpgme_remove_io_cb_t result;
12803 :
12804 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_remove_get",&obj0)) SWIG_fail;
12805 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12806 0 : if (!SWIG_IsOK(res1)) {
12807 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_remove_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12808 : }
12809 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12810 : {
12811 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12812 0 : result = (gpgme_remove_io_cb_t) ((arg1)->remove);
12813 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12814 : }
12815 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
12816 0 : return resultobj;
12817 : fail:
12818 : return NULL;
12819 : }
12820 :
12821 :
12822 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12823 0 : PyObject *resultobj = 0;
12824 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12825 0 : gpgme_event_io_cb_t arg2 = (gpgme_event_io_cb_t) 0 ;
12826 0 : void *argp1 = 0 ;
12827 0 : int res1 = 0 ;
12828 0 : PyObject * obj0 = 0 ;
12829 0 : PyObject * obj1 = 0 ;
12830 :
12831 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_event_set",&obj0,&obj1)) SWIG_fail;
12832 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12833 0 : if (!SWIG_IsOK(res1)) {
12834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12835 : }
12836 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12837 : {
12838 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
12839 0 : if (!SWIG_IsOK(res)) {
12840 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_io_cbs_event_set" "', argument " "2"" of type '" "gpgme_event_io_cb_t""'");
12841 : }
12842 : }
12843 : {
12844 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12845 0 : if (arg1) (arg1)->event = arg2;
12846 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12847 : }
12848 0 : resultobj = SWIG_Py_Void();
12849 0 : return resultobj;
12850 : fail:
12851 : return NULL;
12852 : }
12853 :
12854 :
12855 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12856 0 : PyObject *resultobj = 0;
12857 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12858 0 : void *argp1 = 0 ;
12859 0 : int res1 = 0 ;
12860 0 : PyObject * obj0 = 0 ;
12861 : gpgme_event_io_cb_t result;
12862 :
12863 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_get",&obj0)) SWIG_fail;
12864 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12865 0 : if (!SWIG_IsOK(res1)) {
12866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12867 : }
12868 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12869 : {
12870 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12871 0 : result = (gpgme_event_io_cb_t) ((arg1)->event);
12872 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12873 : }
12874 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_enum_gpgme_event_io_t_p_void__void);
12875 0 : return resultobj;
12876 : fail:
12877 : return NULL;
12878 : }
12879 :
12880 :
12881 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12882 0 : PyObject *resultobj = 0;
12883 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12884 0 : void *arg2 = (void *) 0 ;
12885 0 : void *argp1 = 0 ;
12886 0 : int res1 = 0 ;
12887 : int res2 ;
12888 0 : PyObject * obj0 = 0 ;
12889 0 : PyObject * obj1 = 0 ;
12890 :
12891 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_io_cbs_event_priv_set",&obj0,&obj1)) SWIG_fail;
12892 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12893 0 : if (!SWIG_IsOK(res1)) {
12894 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12895 : }
12896 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12897 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
12898 0 : if (!SWIG_IsOK(res2)) {
12899 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_cbs_event_priv_set" "', argument " "2"" of type '" "void *""'");
12900 : }
12901 : {
12902 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12903 0 : if (arg1) (arg1)->event_priv = arg2;
12904 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12905 : }
12906 0 : resultobj = SWIG_Py_Void();
12907 0 : return resultobj;
12908 : fail:
12909 : return NULL;
12910 : }
12911 :
12912 :
12913 0 : SWIGINTERN PyObject *_wrap_gpgme_io_cbs_event_priv_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914 0 : PyObject *resultobj = 0;
12915 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12916 0 : void *argp1 = 0 ;
12917 0 : int res1 = 0 ;
12918 0 : PyObject * obj0 = 0 ;
12919 0 : void *result = 0 ;
12920 :
12921 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_io_cbs_event_priv_get",&obj0)) SWIG_fail;
12922 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
12923 0 : if (!SWIG_IsOK(res1)) {
12924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_io_cbs_event_priv_get" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12925 : }
12926 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12927 : {
12928 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12929 0 : result = (void *) ((arg1)->event_priv);
12930 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12931 : }
12932 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
12933 0 : return resultobj;
12934 : fail:
12935 : return NULL;
12936 : }
12937 :
12938 :
12939 0 : SWIGINTERN PyObject *_wrap_new_gpgme_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12940 0 : PyObject *resultobj = 0;
12941 0 : struct gpgme_io_cbs *result = 0 ;
12942 :
12943 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_io_cbs")) SWIG_fail;
12944 : {
12945 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12946 0 : result = (struct gpgme_io_cbs *)calloc(1, sizeof(struct gpgme_io_cbs));
12947 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12948 : }
12949 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_io_cbs, SWIG_POINTER_NEW | 0 );
12950 0 : return resultobj;
12951 : fail:
12952 : return NULL;
12953 : }
12954 :
12955 :
12956 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12957 0 : PyObject *resultobj = 0;
12958 0 : struct gpgme_io_cbs *arg1 = (struct gpgme_io_cbs *) 0 ;
12959 0 : void *argp1 = 0 ;
12960 0 : int res1 = 0 ;
12961 0 : PyObject * obj0 = 0 ;
12962 :
12963 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_io_cbs",&obj0)) SWIG_fail;
12964 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_io_cbs, SWIG_POINTER_DISOWN | 0 );
12965 0 : if (!SWIG_IsOK(res1)) {
12966 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_io_cbs" "', argument " "1"" of type '" "struct gpgme_io_cbs *""'");
12967 : }
12968 0 : arg1 = (struct gpgme_io_cbs *)(argp1);
12969 : {
12970 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
12971 0 : free((char *) arg1);
12972 0 : SWIG_PYTHON_THREAD_END_ALLOW;
12973 : }
12974 0 : resultobj = SWIG_Py_Void();
12975 0 : return resultobj;
12976 : fail:
12977 : return NULL;
12978 : }
12979 :
12980 :
12981 27 : SWIGINTERN PyObject *gpgme_io_cbs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12982 : PyObject *obj;
12983 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
12984 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_io_cbs, SWIG_NewClientData(obj));
12985 27 : return SWIG_Py_Void();
12986 : }
12987 :
12988 0 : SWIGINTERN PyObject *_wrap_gpgme_set_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12989 0 : PyObject *resultobj = 0;
12990 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
12991 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
12992 0 : void *argp1 = 0 ;
12993 0 : int res1 = 0 ;
12994 0 : void *argp2 = 0 ;
12995 0 : int res2 = 0 ;
12996 0 : PyObject * obj0 = 0 ;
12997 0 : PyObject * obj1 = 0 ;
12998 :
12999 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_io_cbs",&obj0,&obj1)) SWIG_fail;
13000 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13001 0 : if (!SWIG_IsOK(res1)) {
13002 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_set_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13003 : }
13004 0 : arg1 = (gpgme_ctx_t)(argp1);
13005 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13006 0 : if (!SWIG_IsOK(res2)) {
13007 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_set_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
13008 : }
13009 0 : arg2 = (gpgme_io_cbs_t)(argp2);
13010 : {
13011 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13012 0 : gpgme_set_io_cbs(arg1,arg2);
13013 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13014 : }
13015 0 : resultobj = SWIG_Py_Void();
13016 0 : return resultobj;
13017 : fail:
13018 : return NULL;
13019 : }
13020 :
13021 :
13022 0 : SWIGINTERN PyObject *_wrap_gpgme_get_io_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13023 0 : PyObject *resultobj = 0;
13024 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13025 0 : gpgme_io_cbs_t arg2 = (gpgme_io_cbs_t) 0 ;
13026 0 : void *argp1 = 0 ;
13027 0 : int res1 = 0 ;
13028 0 : void *argp2 = 0 ;
13029 0 : int res2 = 0 ;
13030 0 : PyObject * obj0 = 0 ;
13031 0 : PyObject * obj1 = 0 ;
13032 :
13033 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_get_io_cbs",&obj0,&obj1)) SWIG_fail;
13034 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13035 0 : if (!SWIG_IsOK(res1)) {
13036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_io_cbs" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13037 : }
13038 0 : arg1 = (gpgme_ctx_t)(argp1);
13039 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_io_cbs, 0 | 0 );
13040 0 : if (!SWIG_IsOK(res2)) {
13041 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_get_io_cbs" "', argument " "2"" of type '" "gpgme_io_cbs_t""'");
13042 : }
13043 0 : arg2 = (gpgme_io_cbs_t)(argp2);
13044 : {
13045 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13046 0 : gpgme_get_io_cbs(arg1,arg2);
13047 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13048 : }
13049 0 : resultobj = SWIG_Py_Void();
13050 0 : return resultobj;
13051 : fail:
13052 : return NULL;
13053 : }
13054 :
13055 :
13056 0 : SWIGINTERN PyObject *_wrap_gpgme_io_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13057 0 : PyObject *resultobj = 0;
13058 : int arg1 ;
13059 0 : void *arg2 = (void *) 0 ;
13060 : size_t arg3 ;
13061 : int val1 ;
13062 0 : int ecode1 = 0 ;
13063 : int res2 ;
13064 : size_t val3 ;
13065 0 : int ecode3 = 0 ;
13066 0 : PyObject * obj0 = 0 ;
13067 0 : PyObject * obj1 = 0 ;
13068 0 : PyObject * obj2 = 0 ;
13069 : ssize_t result;
13070 :
13071 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_read",&obj0,&obj1,&obj2)) SWIG_fail;
13072 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13073 0 : if (!SWIG_IsOK(ecode1)) {
13074 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_read" "', argument " "1"" of type '" "int""'");
13075 : }
13076 0 : arg1 = (int)(val1);
13077 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13078 0 : if (!SWIG_IsOK(res2)) {
13079 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_read" "', argument " "2"" of type '" "void *""'");
13080 : }
13081 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13082 0 : if (!SWIG_IsOK(ecode3)) {
13083 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_read" "', argument " "3"" of type '" "size_t""'");
13084 : }
13085 0 : arg3 = (size_t)(val3);
13086 : {
13087 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13088 0 : result = gpgme_io_read(arg1,arg2,arg3);
13089 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13090 : }
13091 : {
13092 0 : resultobj = PyLong_FromLong(result);
13093 : }
13094 0 : return resultobj;
13095 : fail:
13096 : return NULL;
13097 : }
13098 :
13099 :
13100 0 : SWIGINTERN PyObject *_wrap_gpgme_io_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13101 0 : PyObject *resultobj = 0;
13102 : int arg1 ;
13103 0 : void *arg2 = (void *) 0 ;
13104 : size_t arg3 ;
13105 : int val1 ;
13106 0 : int ecode1 = 0 ;
13107 : int res2 ;
13108 : size_t val3 ;
13109 0 : int ecode3 = 0 ;
13110 0 : PyObject * obj0 = 0 ;
13111 0 : PyObject * obj1 = 0 ;
13112 0 : PyObject * obj2 = 0 ;
13113 : ssize_t result;
13114 :
13115 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_write",&obj0,&obj1,&obj2)) SWIG_fail;
13116 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13117 0 : if (!SWIG_IsOK(ecode1)) {
13118 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_write" "', argument " "1"" of type '" "int""'");
13119 : }
13120 0 : arg1 = (int)(val1);
13121 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13122 0 : if (!SWIG_IsOK(res2)) {
13123 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_write" "', argument " "2"" of type '" "void const *""'");
13124 : }
13125 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13126 0 : if (!SWIG_IsOK(ecode3)) {
13127 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_write" "', argument " "3"" of type '" "size_t""'");
13128 : }
13129 0 : arg3 = (size_t)(val3);
13130 : {
13131 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13132 0 : result = gpgme_io_write(arg1,(void const *)arg2,arg3);
13133 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13134 : }
13135 : {
13136 0 : resultobj = PyLong_FromLong(result);
13137 : }
13138 0 : return resultobj;
13139 : fail:
13140 : return NULL;
13141 : }
13142 :
13143 :
13144 0 : SWIGINTERN PyObject *_wrap_gpgme_io_writen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13145 0 : PyObject *resultobj = 0;
13146 : int arg1 ;
13147 0 : void *arg2 = (void *) 0 ;
13148 : size_t arg3 ;
13149 : int val1 ;
13150 0 : int ecode1 = 0 ;
13151 : int res2 ;
13152 : size_t val3 ;
13153 0 : int ecode3 = 0 ;
13154 0 : PyObject * obj0 = 0 ;
13155 0 : PyObject * obj1 = 0 ;
13156 0 : PyObject * obj2 = 0 ;
13157 : int result;
13158 :
13159 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_io_writen",&obj0,&obj1,&obj2)) SWIG_fail;
13160 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
13161 0 : if (!SWIG_IsOK(ecode1)) {
13162 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_io_writen" "', argument " "1"" of type '" "int""'");
13163 : }
13164 0 : arg1 = (int)(val1);
13165 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, 0);
13166 0 : if (!SWIG_IsOK(res2)) {
13167 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_io_writen" "', argument " "2"" of type '" "void const *""'");
13168 : }
13169 0 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13170 0 : if (!SWIG_IsOK(ecode3)) {
13171 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_io_writen" "', argument " "3"" of type '" "size_t""'");
13172 : }
13173 0 : arg3 = (size_t)(val3);
13174 : {
13175 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13176 0 : result = (int)gpgme_io_writen(arg1,(void const *)arg2,arg3);
13177 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13178 : }
13179 0 : resultobj = SWIG_From_int((int)(result));
13180 0 : return resultobj;
13181 : fail:
13182 : return NULL;
13183 : }
13184 :
13185 :
13186 3 : SWIGINTERN PyObject *_wrap_gpgme_wait(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13187 3 : PyObject *resultobj = 0;
13188 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13189 3 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
13190 : int arg3 ;
13191 3 : void *argp1 = 0 ;
13192 3 : int res1 = 0 ;
13193 3 : void *argp2 = 0 ;
13194 3 : int res2 = 0 ;
13195 : int val3 ;
13196 3 : int ecode3 = 0 ;
13197 3 : PyObject * obj0 = 0 ;
13198 3 : PyObject * obj1 = 0 ;
13199 3 : PyObject * obj2 = 0 ;
13200 : gpgme_ctx_t result;
13201 :
13202 3 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_wait",&obj0,&obj1,&obj2)) SWIG_fail;
13203 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13204 3 : if (!SWIG_IsOK(res1)) {
13205 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13206 : }
13207 3 : arg1 = (gpgme_ctx_t)(argp1);
13208 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13209 3 : if (!SWIG_IsOK(res2)) {
13210 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait" "', argument " "2"" of type '" "gpgme_error_t *""'");
13211 : }
13212 3 : arg2 = (gpgme_error_t *)(argp2);
13213 6 : ecode3 = SWIG_AsVal_int(obj2, &val3);
13214 3 : if (!SWIG_IsOK(ecode3)) {
13215 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_wait" "', argument " "3"" of type '" "int""'");
13216 : }
13217 3 : arg3 = (int)(val3);
13218 : {
13219 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13220 3 : result = (gpgme_ctx_t)gpgme_wait(arg1,arg2,arg3);
13221 3 : SWIG_PYTHON_THREAD_END_ALLOW;
13222 : }
13223 3 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
13224 3 : return resultobj;
13225 : fail:
13226 : return NULL;
13227 : }
13228 :
13229 :
13230 0 : SWIGINTERN PyObject *_wrap_gpgme_wait_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13231 0 : PyObject *resultobj = 0;
13232 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13233 0 : gpgme_error_t *arg2 = (gpgme_error_t *) 0 ;
13234 0 : gpgme_error_t *arg3 = (gpgme_error_t *) 0 ;
13235 : int arg4 ;
13236 0 : void *argp1 = 0 ;
13237 0 : int res1 = 0 ;
13238 0 : void *argp2 = 0 ;
13239 0 : int res2 = 0 ;
13240 0 : void *argp3 = 0 ;
13241 0 : int res3 = 0 ;
13242 : int val4 ;
13243 0 : int ecode4 = 0 ;
13244 0 : PyObject * obj0 = 0 ;
13245 0 : PyObject * obj1 = 0 ;
13246 0 : PyObject * obj2 = 0 ;
13247 0 : PyObject * obj3 = 0 ;
13248 : gpgme_ctx_t result;
13249 :
13250 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_wait_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13251 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13252 0 : if (!SWIG_IsOK(res1)) {
13253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_wait_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13254 : }
13255 0 : arg1 = (gpgme_ctx_t)(argp1);
13256 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13257 0 : if (!SWIG_IsOK(res2)) {
13258 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_wait_ext" "', argument " "2"" of type '" "gpgme_error_t *""'");
13259 : }
13260 0 : arg2 = (gpgme_error_t *)(argp2);
13261 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpg_error_t, 0 | 0 );
13262 0 : if (!SWIG_IsOK(res3)) {
13263 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_wait_ext" "', argument " "3"" of type '" "gpgme_error_t *""'");
13264 : }
13265 0 : arg3 = (gpgme_error_t *)(argp3);
13266 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
13267 0 : if (!SWIG_IsOK(ecode4)) {
13268 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_wait_ext" "', argument " "4"" of type '" "int""'");
13269 : }
13270 0 : arg4 = (int)(val4);
13271 : {
13272 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13273 0 : result = (gpgme_ctx_t)gpgme_wait_ext(arg1,arg2,arg3,arg4);
13274 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13275 : }
13276 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
13277 0 : return resultobj;
13278 : fail:
13279 : return NULL;
13280 : }
13281 :
13282 :
13283 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13284 0 : PyObject *resultobj = 0;
13285 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13286 0 : void *argp1 = 0 ;
13287 0 : int res1 = 0 ;
13288 0 : PyObject * obj0 = 0 ;
13289 : gpgme_error_t result;
13290 :
13291 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel",&obj0)) SWIG_fail;
13292 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13293 0 : if (!SWIG_IsOK(res1)) {
13294 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13295 : }
13296 0 : arg1 = (gpgme_ctx_t)(argp1);
13297 : {
13298 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13299 0 : result = gpgme_cancel(arg1);
13300 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13301 : }
13302 : {
13303 0 : resultobj = PyLong_FromLong(result);
13304 : }
13305 0 : return resultobj;
13306 : fail:
13307 : return NULL;
13308 : }
13309 :
13310 :
13311 0 : SWIGINTERN PyObject *_wrap_gpgme_cancel_async(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13312 0 : PyObject *resultobj = 0;
13313 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
13314 0 : void *argp1 = 0 ;
13315 0 : int res1 = 0 ;
13316 0 : PyObject * obj0 = 0 ;
13317 : gpgme_error_t result;
13318 :
13319 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_cancel_async",&obj0)) SWIG_fail;
13320 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
13321 0 : if (!SWIG_IsOK(res1)) {
13322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_cancel_async" "', argument " "1"" of type '" "gpgme_ctx_t""'");
13323 : }
13324 0 : arg1 = (gpgme_ctx_t)(argp1);
13325 : {
13326 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13327 0 : result = gpgme_cancel_async(arg1);
13328 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13329 : }
13330 : {
13331 0 : resultobj = PyLong_FromLong(result);
13332 : }
13333 0 : return resultobj;
13334 : fail:
13335 : return NULL;
13336 : }
13337 :
13338 :
13339 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13340 0 : PyObject *resultobj = 0;
13341 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13342 0 : gpgme_data_read_cb_t arg2 = (gpgme_data_read_cb_t) 0 ;
13343 0 : void *argp1 = 0 ;
13344 0 : int res1 = 0 ;
13345 0 : PyObject * obj0 = 0 ;
13346 0 : PyObject * obj1 = 0 ;
13347 :
13348 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_read_set",&obj0,&obj1)) SWIG_fail;
13349 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13350 0 : if (!SWIG_IsOK(res1)) {
13351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13352 : }
13353 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13354 : {
13355 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
13356 0 : if (!SWIG_IsOK(res)) {
13357 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_read_set" "', argument " "2"" of type '" "gpgme_data_read_cb_t""'");
13358 : }
13359 : }
13360 : {
13361 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13362 0 : if (arg1) (arg1)->read = arg2;
13363 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13364 : }
13365 0 : resultobj = SWIG_Py_Void();
13366 0 : return resultobj;
13367 : fail:
13368 : return NULL;
13369 : }
13370 :
13371 :
13372 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_read_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13373 0 : PyObject *resultobj = 0;
13374 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13375 0 : void *argp1 = 0 ;
13376 0 : int res1 = 0 ;
13377 0 : PyObject * obj0 = 0 ;
13378 : gpgme_data_read_cb_t result;
13379 :
13380 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_read_get",&obj0)) SWIG_fail;
13381 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13382 0 : if (!SWIG_IsOK(res1)) {
13383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_read_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13384 : }
13385 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13386 : {
13387 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13388 0 : result = (gpgme_data_read_cb_t) ((arg1)->read);
13389 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13390 : }
13391 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_void_size_t__ssize_t);
13392 0 : return resultobj;
13393 : fail:
13394 : return NULL;
13395 : }
13396 :
13397 :
13398 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13399 0 : PyObject *resultobj = 0;
13400 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13401 0 : gpgme_data_write_cb_t arg2 = (gpgme_data_write_cb_t) 0 ;
13402 0 : void *argp1 = 0 ;
13403 0 : int res1 = 0 ;
13404 0 : PyObject * obj0 = 0 ;
13405 0 : PyObject * obj1 = 0 ;
13406 :
13407 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_write_set",&obj0,&obj1)) SWIG_fail;
13408 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13409 0 : if (!SWIG_IsOK(res1)) {
13410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13411 : }
13412 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13413 : {
13414 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
13415 0 : if (!SWIG_IsOK(res)) {
13416 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_write_set" "', argument " "2"" of type '" "gpgme_data_write_cb_t""'");
13417 : }
13418 : }
13419 : {
13420 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13421 0 : if (arg1) (arg1)->write = arg2;
13422 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13423 : }
13424 0 : resultobj = SWIG_Py_Void();
13425 0 : return resultobj;
13426 : fail:
13427 : return NULL;
13428 : }
13429 :
13430 :
13431 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_write_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13432 0 : PyObject *resultobj = 0;
13433 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13434 0 : void *argp1 = 0 ;
13435 0 : int res1 = 0 ;
13436 0 : PyObject * obj0 = 0 ;
13437 : gpgme_data_write_cb_t result;
13438 :
13439 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_write_get",&obj0)) SWIG_fail;
13440 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13441 0 : if (!SWIG_IsOK(res1)) {
13442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_write_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13443 : }
13444 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13445 : {
13446 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13447 0 : result = (gpgme_data_write_cb_t) ((arg1)->write);
13448 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13449 : }
13450 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_p_q_const__void_size_t__ssize_t);
13451 0 : return resultobj;
13452 : fail:
13453 : return NULL;
13454 : }
13455 :
13456 :
13457 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 0 : PyObject *resultobj = 0;
13459 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13460 0 : gpgme_data_seek_cb_t arg2 = (gpgme_data_seek_cb_t) 0 ;
13461 0 : void *argp1 = 0 ;
13462 0 : int res1 = 0 ;
13463 0 : PyObject * obj0 = 0 ;
13464 0 : PyObject * obj1 = 0 ;
13465 :
13466 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_seek_set",&obj0,&obj1)) SWIG_fail;
13467 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13468 0 : if (!SWIG_IsOK(res1)) {
13469 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13470 : }
13471 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13472 : {
13473 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void_off_t_int__off_t);
13474 0 : if (!SWIG_IsOK(res)) {
13475 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_seek_set" "', argument " "2"" of type '" "gpgme_data_seek_cb_t""'");
13476 : }
13477 : }
13478 : {
13479 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13480 0 : if (arg1) (arg1)->seek = arg2;
13481 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13482 : }
13483 0 : resultobj = SWIG_Py_Void();
13484 0 : return resultobj;
13485 : fail:
13486 : return NULL;
13487 : }
13488 :
13489 :
13490 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_seek_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13491 0 : PyObject *resultobj = 0;
13492 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13493 0 : void *argp1 = 0 ;
13494 0 : int res1 = 0 ;
13495 0 : PyObject * obj0 = 0 ;
13496 : gpgme_data_seek_cb_t result;
13497 :
13498 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_seek_get",&obj0)) SWIG_fail;
13499 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13500 0 : if (!SWIG_IsOK(res1)) {
13501 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_seek_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13502 : }
13503 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13504 : {
13505 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13506 0 : result = (gpgme_data_seek_cb_t) ((arg1)->seek);
13507 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13508 : }
13509 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void_off_t_int__off_t);
13510 0 : return resultobj;
13511 : fail:
13512 : return NULL;
13513 : }
13514 :
13515 :
13516 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13517 0 : PyObject *resultobj = 0;
13518 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13519 0 : gpgme_data_release_cb_t arg2 = (gpgme_data_release_cb_t) 0 ;
13520 0 : void *argp1 = 0 ;
13521 0 : int res1 = 0 ;
13522 0 : PyObject * obj0 = 0 ;
13523 0 : PyObject * obj1 = 0 ;
13524 :
13525 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_cbs_release_set",&obj0,&obj1)) SWIG_fail;
13526 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13527 0 : if (!SWIG_IsOK(res1)) {
13528 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_set" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13529 : }
13530 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13531 : {
13532 0 : int res = SWIG_ConvertFunctionPtr(obj1, (void**)(&arg2), SWIGTYPE_p_f_p_void__void);
13533 0 : if (!SWIG_IsOK(res)) {
13534 0 : SWIG_exception_fail(SWIG_ArgError(res), "in method '" "gpgme_data_cbs_release_set" "', argument " "2"" of type '" "gpgme_data_release_cb_t""'");
13535 : }
13536 : }
13537 : {
13538 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13539 0 : if (arg1) (arg1)->release = arg2;
13540 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13541 : }
13542 0 : resultobj = SWIG_Py_Void();
13543 0 : return resultobj;
13544 : fail:
13545 : return NULL;
13546 : }
13547 :
13548 :
13549 0 : SWIGINTERN PyObject *_wrap_gpgme_data_cbs_release_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13550 0 : PyObject *resultobj = 0;
13551 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13552 0 : void *argp1 = 0 ;
13553 0 : int res1 = 0 ;
13554 0 : PyObject * obj0 = 0 ;
13555 : gpgme_data_release_cb_t result;
13556 :
13557 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_cbs_release_get",&obj0)) SWIG_fail;
13558 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
13559 0 : if (!SWIG_IsOK(res1)) {
13560 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_cbs_release_get" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13561 : }
13562 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13563 : {
13564 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13565 0 : result = (gpgme_data_release_cb_t) ((arg1)->release);
13566 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13567 : }
13568 0 : resultobj = SWIG_NewFunctionPtrObj((void *)(result), SWIGTYPE_p_f_p_void__void);
13569 0 : return resultobj;
13570 : fail:
13571 : return NULL;
13572 : }
13573 :
13574 :
13575 0 : SWIGINTERN PyObject *_wrap_new_gpgme_data_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13576 0 : PyObject *resultobj = 0;
13577 0 : struct gpgme_data_cbs *result = 0 ;
13578 :
13579 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_data_cbs")) SWIG_fail;
13580 : {
13581 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13582 0 : result = (struct gpgme_data_cbs *)calloc(1, sizeof(struct gpgme_data_cbs));
13583 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13584 : }
13585 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data_cbs, SWIG_POINTER_NEW | 0 );
13586 0 : return resultobj;
13587 : fail:
13588 : return NULL;
13589 : }
13590 :
13591 :
13592 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13593 0 : PyObject *resultobj = 0;
13594 0 : struct gpgme_data_cbs *arg1 = (struct gpgme_data_cbs *) 0 ;
13595 0 : void *argp1 = 0 ;
13596 0 : int res1 = 0 ;
13597 0 : PyObject * obj0 = 0 ;
13598 :
13599 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_data_cbs",&obj0)) SWIG_fail;
13600 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data_cbs, SWIG_POINTER_DISOWN | 0 );
13601 0 : if (!SWIG_IsOK(res1)) {
13602 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_cbs" "', argument " "1"" of type '" "struct gpgme_data_cbs *""'");
13603 : }
13604 0 : arg1 = (struct gpgme_data_cbs *)(argp1);
13605 : {
13606 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13607 0 : free((char *) arg1);
13608 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13609 : }
13610 0 : resultobj = SWIG_Py_Void();
13611 0 : return resultobj;
13612 : fail:
13613 : return NULL;
13614 : }
13615 :
13616 :
13617 27 : SWIGINTERN PyObject *gpgme_data_cbs_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13618 : PyObject *obj;
13619 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
13620 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_data_cbs, SWIG_NewClientData(obj));
13621 27 : return SWIG_Py_Void();
13622 : }
13623 :
13624 78 : SWIGINTERN PyObject *_wrap_gpgme_data_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13625 78 : PyObject *resultobj = 0;
13626 78 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
13627 78 : void *arg2 = (void *) 0 ;
13628 : size_t arg3 ;
13629 78 : void *argp1 = 0 ;
13630 78 : int res1 = 0 ;
13631 78 : PyObject * obj0 = 0 ;
13632 78 : PyObject * obj1 = 0 ;
13633 : ssize_t result;
13634 :
13635 78 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_read",&obj0,&obj1)) SWIG_fail;
13636 78 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
13637 78 : if (!SWIG_IsOK(res1)) {
13638 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_read" "', argument " "1"" of type '" "gpgme_data_t""'");
13639 : }
13640 78 : arg1 = (gpgme_data_t)(argp1);
13641 : {
13642 : {
13643 : long tmp2;
13644 78 : if (PyLong_Check(obj1))
13645 0 : tmp2 = PyLong_AsLong(obj1);
13646 :
13647 78 : else if (PyInt_Check(obj1))
13648 78 : tmp2 = PyInt_AsLong(obj1);
13649 :
13650 : else
13651 : {
13652 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
13653 0 : return NULL;
13654 : }
13655 :
13656 78 : if (tmp2 < 0) {
13657 0 : PyErr_SetString(PyExc_ValueError, "Positive integer expected");
13658 0 : return NULL;
13659 : }
13660 78 : arg3 = (size_t) tmp2;
13661 78 : arg2 = (void *) malloc(arg3+1);
13662 : }
13663 : }
13664 : {
13665 78 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13666 78 : result = gpgme_data_read(arg1,arg2,arg3);
13667 78 : SWIG_PYTHON_THREAD_END_ALLOW;
13668 : }
13669 : {
13670 78 : resultobj = PyLong_FromLong(result);
13671 : }
13672 : {
13673 78 : Py_XDECREF(resultobj); /* Blow away any previous result */
13674 78 : if (result < 0) {
13675 : /* Check for I/O error */
13676 2 : free(arg2);
13677 2 : return PyErr_SetFromErrno(PyExc_RuntimeError);
13678 : }
13679 76 : resultobj = PyBytes_FromStringAndSize(arg2,result);
13680 76 : free(arg2);
13681 : }
13682 76 : return resultobj;
13683 : fail:
13684 : return NULL;
13685 : }
13686 :
13687 :
13688 8 : SWIGINTERN PyObject *_wrap_gpgme_data_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13689 8 : PyObject *resultobj = 0;
13690 8 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
13691 8 : void *arg2 = (void *) 0 ;
13692 : size_t arg3 ;
13693 8 : void *argp1 = 0 ;
13694 8 : int res1 = 0 ;
13695 8 : PyObject *encodedInput2 = NULL ;
13696 8 : PyObject * obj0 = 0 ;
13697 8 : PyObject * obj1 = 0 ;
13698 : ssize_t result;
13699 :
13700 8 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_write",&obj0,&obj1)) SWIG_fail;
13701 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
13702 8 : if (!SWIG_IsOK(res1)) {
13703 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_write" "', argument " "1"" of type '" "gpgme_data_t""'");
13704 : }
13705 8 : arg1 = (gpgme_data_t)(argp1);
13706 : {
13707 : Py_ssize_t ssize;
13708 :
13709 8 : if (obj1 == Py_None)
13710 0 : arg2 = NULL, arg3 = 0;
13711 8 : else if (PyUnicode_Check(obj1))
13712 : {
13713 3 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
13714 3 : if (encodedInput2 == NULL)
13715 0 : return NULL;
13716 3 : if (PyBytes_AsStringAndSize(encodedInput2, (char **) &arg2, &ssize) == -1)
13717 : {
13718 0 : Py_DECREF(encodedInput2);
13719 : return NULL;
13720 : }
13721 : }
13722 5 : else if (PyBytes_Check(obj1))
13723 5 : PyBytes_AsStringAndSize(obj1, (char **) &arg2, &ssize);
13724 : else {
13725 0 : PyErr_Format(PyExc_TypeError,
13726 : "arg %d: expected str, bytes, or None, got %s",
13727 : 2, obj1->ob_type->tp_name);
13728 0 : return NULL;
13729 : }
13730 :
13731 8 : if (! arg2)
13732 : arg3 = 0;
13733 : else
13734 : {
13735 : assert (ssize >= 0);
13736 8 : arg3 = (size_t) ssize;
13737 : }
13738 : }
13739 : {
13740 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13741 8 : result = gpgme_data_write(arg1,(void const *)arg2,arg3);
13742 8 : SWIG_PYTHON_THREAD_END_ALLOW;
13743 : }
13744 : {
13745 8 : resultobj = PyLong_FromLong(result);
13746 : }
13747 : {
13748 11 : Py_XDECREF(encodedInput2);
13749 : }
13750 : return resultobj;
13751 : fail:
13752 : {
13753 : Py_XDECREF(encodedInput2);
13754 : }
13755 : return NULL;
13756 : }
13757 :
13758 :
13759 39 : SWIGINTERN PyObject *_wrap_gpgme_data_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13760 39 : PyObject *resultobj = 0;
13761 39 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
13762 : off_t arg2 ;
13763 : int arg3 ;
13764 39 : void *argp1 = 0 ;
13765 39 : int res1 = 0 ;
13766 : int val3 ;
13767 39 : int ecode3 = 0 ;
13768 39 : PyObject * obj0 = 0 ;
13769 39 : PyObject * obj1 = 0 ;
13770 39 : PyObject * obj2 = 0 ;
13771 : off_t result;
13772 :
13773 39 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_seek",&obj0,&obj1,&obj2)) SWIG_fail;
13774 39 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
13775 39 : if (!SWIG_IsOK(res1)) {
13776 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_seek" "', argument " "1"" of type '" "gpgme_data_t""'");
13777 : }
13778 39 : arg1 = (gpgme_data_t)(argp1);
13779 : {
13780 39 : if (PyLong_Check(obj1))
13781 :
13782 :
13783 :
13784 0 : arg2 = PyLong_AsLong(obj1);
13785 :
13786 :
13787 39 : else if (PyInt_Check(obj1))
13788 39 : arg2 = PyInt_AsLong(obj1);
13789 :
13790 : else
13791 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
13792 : }
13793 78 : ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 39 : if (!SWIG_IsOK(ecode3)) {
13795 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_seek" "', argument " "3"" of type '" "int""'");
13796 : }
13797 39 : arg3 = (int)(val3);
13798 : {
13799 39 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13800 39 : result = gpgme_data_seek(arg1,arg2,arg3);
13801 39 : SWIG_PYTHON_THREAD_END_ALLOW;
13802 : }
13803 : {
13804 39 : resultobj = PyLong_FromLong(result);
13805 :
13806 : }
13807 39 : return resultobj;
13808 : fail:
13809 : return NULL;
13810 : }
13811 :
13812 :
13813 66 : SWIGINTERN PyObject *_wrap_gpgme_data_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13814 66 : PyObject *resultobj = 0;
13815 66 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
13816 66 : void *argp1 = 0 ;
13817 66 : int res1 = 0 ;
13818 66 : PyObject * obj0 = 0 ;
13819 : gpgme_error_t result;
13820 :
13821 66 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_new",&obj0)) SWIG_fail;
13822 66 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
13823 66 : if (!SWIG_IsOK(res1)) {
13824 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new" "', argument " "1"" of type '" "gpgme_data_t *""'");
13825 : }
13826 66 : arg1 = (gpgme_data_t *)(argp1);
13827 : {
13828 66 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13829 66 : result = gpgme_data_new(arg1);
13830 66 : SWIG_PYTHON_THREAD_END_ALLOW;
13831 : }
13832 : {
13833 66 : resultobj = PyLong_FromLong(result);
13834 : }
13835 66 : return resultobj;
13836 : fail:
13837 : return NULL;
13838 : }
13839 :
13840 :
13841 100 : SWIGINTERN PyObject *_wrap_gpgme_data_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13842 100 : PyObject *resultobj = 0;
13843 100 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
13844 100 : void *argp1 = 0 ;
13845 100 : int res1 = 0 ;
13846 100 : PyObject * obj0 = 0 ;
13847 :
13848 100 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_release",&obj0)) SWIG_fail;
13849 100 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
13850 100 : if (!SWIG_IsOK(res1)) {
13851 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release" "', argument " "1"" of type '" "gpgme_data_t""'");
13852 : }
13853 100 : arg1 = (gpgme_data_t)(argp1);
13854 : {
13855 100 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13856 100 : gpgme_data_release(arg1);
13857 100 : SWIG_PYTHON_THREAD_END_ALLOW;
13858 : }
13859 100 : resultobj = SWIG_Py_Void();
13860 100 : return resultobj;
13861 : fail:
13862 : return NULL;
13863 : }
13864 :
13865 :
13866 24 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_mem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13867 24 : PyObject *resultobj = 0;
13868 24 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
13869 24 : char *arg2 = (char *) 0 ;
13870 : size_t arg3 ;
13871 : int arg4 ;
13872 24 : void *argp1 = 0 ;
13873 24 : int res1 = 0 ;
13874 24 : PyObject *encodedInput2 = NULL ;
13875 : size_t val3 ;
13876 24 : int ecode3 = 0 ;
13877 : int val4 ;
13878 24 : int ecode4 = 0 ;
13879 24 : PyObject * obj0 = 0 ;
13880 24 : PyObject * obj1 = 0 ;
13881 24 : PyObject * obj2 = 0 ;
13882 24 : PyObject * obj3 = 0 ;
13883 : gpgme_error_t result;
13884 :
13885 24 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_data_new_from_mem",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13886 24 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
13887 24 : if (!SWIG_IsOK(res1)) {
13888 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_mem" "', argument " "1"" of type '" "gpgme_data_t *""'");
13889 : }
13890 24 : arg1 = (gpgme_data_t *)(argp1);
13891 : {
13892 24 : if (obj1 == Py_None)
13893 : arg2 = NULL;
13894 24 : else if (PyUnicode_Check(obj1))
13895 : {
13896 16 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
13897 16 : if (encodedInput2 == NULL)
13898 : return NULL;
13899 16 : arg2 = PyBytes_AsString(encodedInput2);
13900 : }
13901 8 : else if (PyBytes_Check(obj1))
13902 8 : arg2 = PyBytes_AsString(obj1);
13903 : else {
13904 0 : PyErr_Format(PyExc_TypeError,
13905 : "arg %d: expected str, bytes, or None, got %s",
13906 : 2, obj1->ob_type->tp_name);
13907 0 : return NULL;
13908 : }
13909 : }
13910 48 : ecode3 = SWIG_AsVal_size_t(obj2, &val3);
13911 24 : if (!SWIG_IsOK(ecode3)) {
13912 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_mem" "', argument " "3"" of type '" "size_t""'");
13913 : }
13914 24 : arg3 = (size_t)(val3);
13915 48 : ecode4 = SWIG_AsVal_int(obj3, &val4);
13916 24 : if (!SWIG_IsOK(ecode4)) {
13917 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_data_new_from_mem" "', argument " "4"" of type '" "int""'");
13918 : }
13919 24 : arg4 = (int)(val4);
13920 : {
13921 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13922 24 : result = gpgme_data_new_from_mem(arg1,(char const *)arg2,arg3,arg4);
13923 24 : SWIG_PYTHON_THREAD_END_ALLOW;
13924 : }
13925 : {
13926 24 : resultobj = PyLong_FromLong(result);
13927 : }
13928 : {
13929 24 : Py_XDECREF(encodedInput2);
13930 : }
13931 : return resultobj;
13932 : fail:
13933 : {
13934 0 : Py_XDECREF(encodedInput2);
13935 : }
13936 : return NULL;
13937 : }
13938 :
13939 :
13940 0 : SWIGINTERN PyObject *_wrap_gpgme_data_release_and_get_mem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13941 0 : PyObject *resultobj = 0;
13942 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
13943 0 : size_t *arg2 = (size_t *) 0 ;
13944 0 : void *argp1 = 0 ;
13945 0 : int res1 = 0 ;
13946 0 : void *argp2 = 0 ;
13947 0 : int res2 = 0 ;
13948 0 : PyObject * obj0 = 0 ;
13949 0 : PyObject * obj1 = 0 ;
13950 0 : char *result = 0 ;
13951 :
13952 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_release_and_get_mem",&obj0,&obj1)) SWIG_fail;
13953 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
13954 0 : if (!SWIG_IsOK(res1)) {
13955 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_release_and_get_mem" "', argument " "1"" of type '" "gpgme_data_t""'");
13956 : }
13957 0 : arg1 = (gpgme_data_t)(argp1);
13958 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_size_t, 0 | 0 );
13959 0 : if (!SWIG_IsOK(res2)) {
13960 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_release_and_get_mem" "', argument " "2"" of type '" "size_t *""'");
13961 : }
13962 0 : arg2 = (size_t *)(argp2);
13963 : {
13964 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13965 0 : result = (char *)gpgme_data_release_and_get_mem(arg1,arg2);
13966 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13967 : }
13968 0 : resultobj = SWIG_FromCharPtr((const char *)result);
13969 0 : gpgme_free(result);
13970 0 : return resultobj;
13971 : fail:
13972 : return NULL;
13973 : }
13974 :
13975 :
13976 0 : SWIGINTERN PyObject *_wrap_gpgme_free(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13977 0 : PyObject *resultobj = 0;
13978 0 : void *arg1 = (void *) 0 ;
13979 : int res1 ;
13980 0 : PyObject * obj0 = 0 ;
13981 :
13982 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_free",&obj0)) SWIG_fail;
13983 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
13984 0 : if (!SWIG_IsOK(res1)) {
13985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_free" "', argument " "1"" of type '" "void *""'");
13986 : }
13987 : {
13988 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
13989 0 : gpgme_free(arg1);
13990 0 : SWIG_PYTHON_THREAD_END_ALLOW;
13991 : }
13992 0 : resultobj = SWIG_Py_Void();
13993 0 : return resultobj;
13994 : fail:
13995 : return NULL;
13996 : }
13997 :
13998 :
13999 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14000 0 : PyObject *resultobj = 0;
14001 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14002 0 : gpgme_data_cbs_t arg2 = (gpgme_data_cbs_t) 0 ;
14003 0 : void *arg3 = (void *) 0 ;
14004 0 : void *argp1 = 0 ;
14005 0 : int res1 = 0 ;
14006 0 : void *argp2 = 0 ;
14007 0 : int res2 = 0 ;
14008 : int res3 ;
14009 0 : PyObject * obj0 = 0 ;
14010 0 : PyObject * obj1 = 0 ;
14011 0 : PyObject * obj2 = 0 ;
14012 : gpgme_error_t result;
14013 :
14014 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
14015 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14016 0 : if (!SWIG_IsOK(res1)) {
14017 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_cbs" "', argument " "1"" of type '" "gpgme_data_t *""'");
14018 : }
14019 0 : arg1 = (gpgme_data_t *)(argp1);
14020 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data_cbs, 0 | 0 );
14021 0 : if (!SWIG_IsOK(res2)) {
14022 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_cbs" "', argument " "2"" of type '" "gpgme_data_cbs_t""'");
14023 : }
14024 0 : arg2 = (gpgme_data_cbs_t)(argp2);
14025 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
14026 0 : if (!SWIG_IsOK(res3)) {
14027 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_cbs" "', argument " "3"" of type '" "void *""'");
14028 : }
14029 : {
14030 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14031 0 : result = gpgme_data_new_from_cbs(arg1,arg2,arg3);
14032 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14033 : }
14034 : {
14035 0 : resultobj = PyLong_FromLong(result);
14036 : }
14037 0 : return resultobj;
14038 : fail:
14039 : return NULL;
14040 : }
14041 :
14042 :
14043 1 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_fd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14044 1 : PyObject *resultobj = 0;
14045 1 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14046 : int arg2 ;
14047 1 : void *argp1 = 0 ;
14048 1 : int res1 = 0 ;
14049 : int val2 ;
14050 1 : int ecode2 = 0 ;
14051 1 : PyObject * obj0 = 0 ;
14052 1 : PyObject * obj1 = 0 ;
14053 : gpgme_error_t result;
14054 :
14055 1 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_fd",&obj0,&obj1)) SWIG_fail;
14056 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14057 1 : if (!SWIG_IsOK(res1)) {
14058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_fd" "', argument " "1"" of type '" "gpgme_data_t *""'");
14059 : }
14060 1 : arg1 = (gpgme_data_t *)(argp1);
14061 2 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 1 : if (!SWIG_IsOK(ecode2)) {
14063 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_new_from_fd" "', argument " "2"" of type '" "int""'");
14064 : }
14065 1 : arg2 = (int)(val2);
14066 : {
14067 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14068 1 : result = gpgme_data_new_from_fd(arg1,arg2);
14069 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14070 : }
14071 : {
14072 1 : resultobj = PyLong_FromLong(result);
14073 : }
14074 1 : return resultobj;
14075 : fail:
14076 : return NULL;
14077 : }
14078 :
14079 :
14080 0 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_stream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14081 0 : PyObject *resultobj = 0;
14082 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14083 0 : FILE *arg2 = (FILE *) 0 ;
14084 0 : void *argp1 = 0 ;
14085 0 : int res1 = 0 ;
14086 0 : void *argp2 = 0 ;
14087 0 : int res2 = 0 ;
14088 0 : PyObject * obj0 = 0 ;
14089 0 : PyObject * obj1 = 0 ;
14090 : gpgme_error_t result;
14091 :
14092 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_new_from_stream",&obj0,&obj1)) SWIG_fail;
14093 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14094 0 : if (!SWIG_IsOK(res1)) {
14095 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_stream" "', argument " "1"" of type '" "gpgme_data_t *""'");
14096 : }
14097 0 : arg1 = (gpgme_data_t *)(argp1);
14098 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_FILE, 0 | 0 );
14099 0 : if (!SWIG_IsOK(res2)) {
14100 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_new_from_stream" "', argument " "2"" of type '" "FILE *""'");
14101 : }
14102 0 : arg2 = (FILE *)(argp2);
14103 : {
14104 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14105 0 : result = gpgme_data_new_from_stream(arg1,arg2);
14106 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14107 : }
14108 : {
14109 0 : resultobj = PyLong_FromLong(result);
14110 : }
14111 0 : return resultobj;
14112 : fail:
14113 : return NULL;
14114 : }
14115 :
14116 :
14117 0 : SWIGINTERN PyObject *_wrap_gpgme_data_get_encoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14118 0 : PyObject *resultobj = 0;
14119 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14120 0 : void *argp1 = 0 ;
14121 0 : int res1 = 0 ;
14122 0 : PyObject * obj0 = 0 ;
14123 : gpgme_data_encoding_t result;
14124 :
14125 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_encoding",&obj0)) SWIG_fail;
14126 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14127 0 : if (!SWIG_IsOK(res1)) {
14128 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
14129 : }
14130 0 : arg1 = (gpgme_data_t)(argp1);
14131 : {
14132 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14133 0 : result = (gpgme_data_encoding_t)gpgme_data_get_encoding(arg1);
14134 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14135 : }
14136 0 : resultobj = SWIG_From_int((int)(result));
14137 0 : return resultobj;
14138 : fail:
14139 : return NULL;
14140 : }
14141 :
14142 :
14143 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_encoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14144 0 : PyObject *resultobj = 0;
14145 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14146 : gpgme_data_encoding_t arg2 ;
14147 0 : void *argp1 = 0 ;
14148 0 : int res1 = 0 ;
14149 : int val2 ;
14150 0 : int ecode2 = 0 ;
14151 0 : PyObject * obj0 = 0 ;
14152 0 : PyObject * obj1 = 0 ;
14153 : gpgme_error_t result;
14154 :
14155 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_encoding",&obj0,&obj1)) SWIG_fail;
14156 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14157 0 : if (!SWIG_IsOK(res1)) {
14158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_encoding" "', argument " "1"" of type '" "gpgme_data_t""'");
14159 : }
14160 0 : arg1 = (gpgme_data_t)(argp1);
14161 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14162 0 : if (!SWIG_IsOK(ecode2)) {
14163 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_set_encoding" "', argument " "2"" of type '" "gpgme_data_encoding_t""'");
14164 : }
14165 0 : arg2 = (gpgme_data_encoding_t)(val2);
14166 : {
14167 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14168 0 : result = gpgme_data_set_encoding(arg1,arg2);
14169 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14170 : }
14171 : {
14172 0 : resultobj = PyLong_FromLong(result);
14173 : }
14174 0 : return resultobj;
14175 : fail:
14176 : return NULL;
14177 : }
14178 :
14179 :
14180 1 : SWIGINTERN PyObject *_wrap_gpgme_data_get_file_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14181 1 : PyObject *resultobj = 0;
14182 1 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14183 1 : void *argp1 = 0 ;
14184 1 : int res1 = 0 ;
14185 1 : PyObject * obj0 = 0 ;
14186 1 : char *result = 0 ;
14187 :
14188 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_get_file_name",&obj0)) SWIG_fail;
14189 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14190 1 : if (!SWIG_IsOK(res1)) {
14191 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_get_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
14192 : }
14193 1 : arg1 = (gpgme_data_t)(argp1);
14194 : {
14195 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14196 1 : result = (char *)gpgme_data_get_file_name(arg1);
14197 1 : SWIG_PYTHON_THREAD_END_ALLOW;
14198 : }
14199 1 : resultobj = SWIG_FromCharPtr((const char *)result);
14200 1 : return resultobj;
14201 : fail:
14202 : return NULL;
14203 : }
14204 :
14205 :
14206 2 : SWIGINTERN PyObject *_wrap_gpgme_data_set_file_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14207 2 : PyObject *resultobj = 0;
14208 2 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14209 2 : char *arg2 = (char *) 0 ;
14210 2 : void *argp1 = 0 ;
14211 2 : int res1 = 0 ;
14212 2 : PyObject *encodedInput2 = NULL ;
14213 2 : PyObject * obj0 = 0 ;
14214 2 : PyObject * obj1 = 0 ;
14215 : gpgme_error_t result;
14216 :
14217 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_set_file_name",&obj0,&obj1)) SWIG_fail;
14218 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14219 2 : if (!SWIG_IsOK(res1)) {
14220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_file_name" "', argument " "1"" of type '" "gpgme_data_t""'");
14221 : }
14222 2 : arg1 = (gpgme_data_t)(argp1);
14223 : {
14224 2 : if (obj1 == Py_None)
14225 : arg2 = NULL;
14226 2 : else if (PyUnicode_Check(obj1))
14227 : {
14228 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14229 2 : if (encodedInput2 == NULL)
14230 : return NULL;
14231 2 : arg2 = PyBytes_AsString(encodedInput2);
14232 : }
14233 0 : else if (PyBytes_Check(obj1))
14234 0 : arg2 = PyBytes_AsString(obj1);
14235 : else {
14236 0 : PyErr_Format(PyExc_TypeError,
14237 : "arg %d: expected str, bytes, or None, got %s",
14238 : 2, obj1->ob_type->tp_name);
14239 0 : return NULL;
14240 : }
14241 : }
14242 : {
14243 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14244 2 : result = gpgme_data_set_file_name(arg1,(char const *)arg2);
14245 2 : SWIG_PYTHON_THREAD_END_ALLOW;
14246 : }
14247 : {
14248 2 : resultobj = PyLong_FromLong(result);
14249 : }
14250 : {
14251 2 : Py_XDECREF(encodedInput2);
14252 : }
14253 : return resultobj;
14254 : fail:
14255 : {
14256 : Py_XDECREF(encodedInput2);
14257 : }
14258 : return NULL;
14259 : }
14260 :
14261 :
14262 0 : SWIGINTERN PyObject *_wrap_gpgme_data_set_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14263 0 : PyObject *resultobj = 0;
14264 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14265 0 : char *arg2 = (char *) 0 ;
14266 0 : char *arg3 = (char *) 0 ;
14267 0 : void *argp1 = 0 ;
14268 0 : int res1 = 0 ;
14269 0 : PyObject *encodedInput2 = NULL ;
14270 0 : PyObject *encodedInput3 = NULL ;
14271 0 : PyObject * obj0 = 0 ;
14272 0 : PyObject * obj1 = 0 ;
14273 0 : PyObject * obj2 = 0 ;
14274 : gpg_error_t result;
14275 :
14276 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_set_flag",&obj0,&obj1,&obj2)) SWIG_fail;
14277 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14278 0 : if (!SWIG_IsOK(res1)) {
14279 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_set_flag" "', argument " "1"" of type '" "gpgme_data_t""'");
14280 : }
14281 0 : arg1 = (gpgme_data_t)(argp1);
14282 : {
14283 0 : if (obj1 == Py_None)
14284 : arg2 = NULL;
14285 0 : else if (PyUnicode_Check(obj1))
14286 : {
14287 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14288 0 : if (encodedInput2 == NULL)
14289 : return NULL;
14290 0 : arg2 = PyBytes_AsString(encodedInput2);
14291 : }
14292 0 : else if (PyBytes_Check(obj1))
14293 0 : arg2 = PyBytes_AsString(obj1);
14294 : else {
14295 0 : PyErr_Format(PyExc_TypeError,
14296 : "arg %d: expected str, bytes, or None, got %s",
14297 : 2, obj1->ob_type->tp_name);
14298 0 : return NULL;
14299 : }
14300 : }
14301 : {
14302 0 : if (obj2 == Py_None)
14303 : arg3 = NULL;
14304 0 : else if (PyUnicode_Check(obj2))
14305 : {
14306 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
14307 0 : if (encodedInput3 == NULL)
14308 : return NULL;
14309 0 : arg3 = PyBytes_AsString(encodedInput3);
14310 : }
14311 0 : else if (PyBytes_Check(obj2))
14312 0 : arg3 = PyBytes_AsString(obj2);
14313 : else {
14314 0 : PyErr_Format(PyExc_TypeError,
14315 : "arg %d: expected str, bytes, or None, got %s",
14316 : 3, obj2->ob_type->tp_name);
14317 0 : return NULL;
14318 : }
14319 : }
14320 : {
14321 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14322 0 : result = gpgme_data_set_flag(arg1,(char const *)arg2,(char const *)arg3);
14323 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14324 : }
14325 : {
14326 0 : resultobj = PyLong_FromLong(result);
14327 : }
14328 : {
14329 0 : Py_XDECREF(encodedInput2);
14330 : }
14331 : {
14332 0 : Py_XDECREF(encodedInput3);
14333 : }
14334 : return resultobj;
14335 : fail:
14336 : {
14337 : Py_XDECREF(encodedInput2);
14338 : }
14339 : {
14340 : Py_XDECREF(encodedInput3);
14341 : }
14342 : return NULL;
14343 : }
14344 :
14345 :
14346 0 : SWIGINTERN PyObject *_wrap_gpgme_data_identify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14347 0 : PyObject *resultobj = 0;
14348 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14349 : int arg2 ;
14350 0 : void *argp1 = 0 ;
14351 0 : int res1 = 0 ;
14352 : int val2 ;
14353 0 : int ecode2 = 0 ;
14354 0 : PyObject * obj0 = 0 ;
14355 0 : PyObject * obj1 = 0 ;
14356 : gpgme_data_type_t result;
14357 :
14358 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_identify",&obj0,&obj1)) SWIG_fail;
14359 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14360 0 : if (!SWIG_IsOK(res1)) {
14361 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_identify" "', argument " "1"" of type '" "gpgme_data_t""'");
14362 : }
14363 0 : arg1 = (gpgme_data_t)(argp1);
14364 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
14365 0 : if (!SWIG_IsOK(ecode2)) {
14366 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_data_identify" "', argument " "2"" of type '" "int""'");
14367 : }
14368 0 : arg2 = (int)(val2);
14369 : {
14370 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14371 0 : result = (gpgme_data_type_t)gpgme_data_identify(arg1,arg2);
14372 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14373 : }
14374 0 : resultobj = SWIG_From_int((int)(result));
14375 0 : return resultobj;
14376 : fail:
14377 : return NULL;
14378 : }
14379 :
14380 :
14381 5 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_file(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14382 5 : PyObject *resultobj = 0;
14383 5 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14384 5 : char *arg2 = (char *) 0 ;
14385 : int arg3 ;
14386 5 : void *argp1 = 0 ;
14387 5 : int res1 = 0 ;
14388 5 : PyObject *encodedInput2 = NULL ;
14389 : int val3 ;
14390 5 : int ecode3 = 0 ;
14391 5 : PyObject * obj0 = 0 ;
14392 5 : PyObject * obj1 = 0 ;
14393 5 : PyObject * obj2 = 0 ;
14394 : gpgme_error_t result;
14395 :
14396 5 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_data_new_from_file",&obj0,&obj1,&obj2)) SWIG_fail;
14397 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14398 5 : if (!SWIG_IsOK(res1)) {
14399 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_file" "', argument " "1"" of type '" "gpgme_data_t *""'");
14400 : }
14401 5 : arg1 = (gpgme_data_t *)(argp1);
14402 : {
14403 5 : if (obj1 == Py_None)
14404 : arg2 = NULL;
14405 5 : else if (PyUnicode_Check(obj1))
14406 : {
14407 4 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14408 4 : if (encodedInput2 == NULL)
14409 : return NULL;
14410 4 : arg2 = PyBytes_AsString(encodedInput2);
14411 : }
14412 1 : else if (PyBytes_Check(obj1))
14413 1 : arg2 = PyBytes_AsString(obj1);
14414 : else {
14415 0 : PyErr_Format(PyExc_TypeError,
14416 : "arg %d: expected str, bytes, or None, got %s",
14417 : 2, obj1->ob_type->tp_name);
14418 0 : return NULL;
14419 : }
14420 : }
14421 10 : ecode3 = SWIG_AsVal_int(obj2, &val3);
14422 5 : if (!SWIG_IsOK(ecode3)) {
14423 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_data_new_from_file" "', argument " "3"" of type '" "int""'");
14424 : }
14425 5 : arg3 = (int)(val3);
14426 : {
14427 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14428 5 : result = gpgme_data_new_from_file(arg1,(char const *)arg2,arg3);
14429 5 : SWIG_PYTHON_THREAD_END_ALLOW;
14430 : }
14431 : {
14432 5 : resultobj = PyLong_FromLong(result);
14433 : }
14434 : {
14435 5 : Py_XDECREF(encodedInput2);
14436 : }
14437 : return resultobj;
14438 : fail:
14439 : {
14440 0 : Py_XDECREF(encodedInput2);
14441 : }
14442 : return NULL;
14443 : }
14444 :
14445 :
14446 2 : SWIGINTERN PyObject *_wrap_gpgme_data_new_from_filepart(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14447 2 : PyObject *resultobj = 0;
14448 2 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
14449 2 : char *arg2 = (char *) 0 ;
14450 2 : FILE *arg3 = (FILE *) 0 ;
14451 : off_t arg4 ;
14452 : size_t arg5 ;
14453 2 : void *argp1 = 0 ;
14454 2 : int res1 = 0 ;
14455 2 : PyObject *encodedInput2 = NULL ;
14456 2 : void *argp3 = 0 ;
14457 2 : int res3 = 0 ;
14458 : size_t val5 ;
14459 2 : int ecode5 = 0 ;
14460 2 : PyObject * obj0 = 0 ;
14461 2 : PyObject * obj1 = 0 ;
14462 2 : PyObject * obj2 = 0 ;
14463 2 : PyObject * obj3 = 0 ;
14464 2 : PyObject * obj4 = 0 ;
14465 : gpgme_error_t result;
14466 :
14467 2 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_data_new_from_filepart",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14468 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
14469 2 : if (!SWIG_IsOK(res1)) {
14470 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_new_from_filepart" "', argument " "1"" of type '" "gpgme_data_t *""'");
14471 : }
14472 2 : arg1 = (gpgme_data_t *)(argp1);
14473 : {
14474 2 : if (obj1 == Py_None)
14475 : arg2 = NULL;
14476 1 : else if (PyUnicode_Check(obj1))
14477 : {
14478 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14479 0 : if (encodedInput2 == NULL)
14480 : return NULL;
14481 0 : arg2 = PyBytes_AsString(encodedInput2);
14482 : }
14483 1 : else if (PyBytes_Check(obj1))
14484 1 : arg2 = PyBytes_AsString(obj1);
14485 : else {
14486 0 : PyErr_Format(PyExc_TypeError,
14487 : "arg %d: expected str, bytes, or None, got %s",
14488 : 2, obj1->ob_type->tp_name);
14489 0 : return NULL;
14490 : }
14491 : }
14492 2 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_FILE, 0 | 0 );
14493 2 : if (!SWIG_IsOK(res3)) {
14494 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_data_new_from_filepart" "', argument " "3"" of type '" "FILE *""'");
14495 : }
14496 2 : arg3 = (FILE *)(argp3);
14497 : {
14498 2 : if (PyLong_Check(obj3))
14499 :
14500 :
14501 :
14502 0 : arg4 = PyLong_AsLong(obj3);
14503 :
14504 :
14505 2 : else if (PyInt_Check(obj3))
14506 2 : arg4 = PyInt_AsLong(obj3);
14507 :
14508 : else
14509 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
14510 : }
14511 4 : ecode5 = SWIG_AsVal_size_t(obj4, &val5);
14512 2 : if (!SWIG_IsOK(ecode5)) {
14513 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_data_new_from_filepart" "', argument " "5"" of type '" "size_t""'");
14514 : }
14515 2 : arg5 = (size_t)(val5);
14516 : {
14517 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14518 2 : result = gpgme_data_new_from_filepart(arg1,(char const *)arg2,arg3,arg4,arg5);
14519 2 : SWIG_PYTHON_THREAD_END_ALLOW;
14520 : }
14521 : {
14522 2 : resultobj = PyLong_FromLong(result);
14523 : }
14524 : {
14525 2 : Py_XDECREF(encodedInput2);
14526 : }
14527 : return resultobj;
14528 : fail:
14529 : {
14530 0 : Py_XDECREF(encodedInput2);
14531 : }
14532 : return NULL;
14533 : }
14534 :
14535 :
14536 0 : SWIGINTERN PyObject *_wrap_gpgme_data_rewind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14537 0 : PyObject *resultobj = 0;
14538 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
14539 0 : void *argp1 = 0 ;
14540 0 : int res1 = 0 ;
14541 0 : PyObject * obj0 = 0 ;
14542 : gpgme_error_t result;
14543 :
14544 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_rewind",&obj0)) SWIG_fail;
14545 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
14546 0 : if (!SWIG_IsOK(res1)) {
14547 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_rewind" "', argument " "1"" of type '" "gpgme_data_t""'");
14548 : }
14549 0 : arg1 = (gpgme_data_t)(argp1);
14550 : {
14551 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14552 0 : result = gpgme_data_rewind(arg1);
14553 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14554 : }
14555 : {
14556 0 : resultobj = PyLong_FromLong(result);
14557 : }
14558 0 : return resultobj;
14559 : fail:
14560 : return NULL;
14561 : }
14562 :
14563 :
14564 66 : SWIGINTERN PyObject *_wrap_gpgme_get_key(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14565 66 : PyObject *resultobj = 0;
14566 66 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
14567 66 : char *arg2 = (char *) 0 ;
14568 66 : gpgme_key_t *arg3 = (gpgme_key_t *) 0 ;
14569 : int arg4 ;
14570 66 : void *argp1 = 0 ;
14571 66 : int res1 = 0 ;
14572 66 : PyObject *encodedInput2 = NULL ;
14573 66 : void *argp3 = 0 ;
14574 66 : int res3 = 0 ;
14575 : int val4 ;
14576 66 : int ecode4 = 0 ;
14577 66 : PyObject * obj0 = 0 ;
14578 66 : PyObject * obj1 = 0 ;
14579 66 : PyObject * obj2 = 0 ;
14580 66 : PyObject * obj3 = 0 ;
14581 : gpgme_error_t result;
14582 :
14583 66 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_get_key",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14584 66 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
14585 66 : if (!SWIG_IsOK(res1)) {
14586 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_key" "', argument " "1"" of type '" "gpgme_ctx_t""'");
14587 : }
14588 66 : arg1 = (gpgme_ctx_t)(argp1);
14589 : {
14590 66 : if (obj1 == Py_None)
14591 : arg2 = NULL;
14592 66 : else if (PyUnicode_Check(obj1))
14593 : {
14594 29 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14595 29 : if (encodedInput2 == NULL)
14596 : return NULL;
14597 29 : arg2 = PyBytes_AsString(encodedInput2);
14598 : }
14599 37 : else if (PyBytes_Check(obj1))
14600 37 : arg2 = PyBytes_AsString(obj1);
14601 : else {
14602 0 : PyErr_Format(PyExc_TypeError,
14603 : "arg %d: expected str, bytes, or None, got %s",
14604 : 2, obj1->ob_type->tp_name);
14605 0 : return NULL;
14606 : }
14607 : }
14608 66 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
14609 66 : if (!SWIG_IsOK(res3)) {
14610 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_get_key" "', argument " "3"" of type '" "gpgme_key_t *""'");
14611 : }
14612 66 : arg3 = (gpgme_key_t *)(argp3);
14613 132 : ecode4 = SWIG_AsVal_int(obj3, &val4);
14614 66 : if (!SWIG_IsOK(ecode4)) {
14615 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_get_key" "', argument " "4"" of type '" "int""'");
14616 : }
14617 66 : arg4 = (int)(val4);
14618 : {
14619 66 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14620 66 : result = gpgme_get_key(arg1,(char const *)arg2,arg3,arg4);
14621 66 : SWIG_PYTHON_THREAD_END_ALLOW;
14622 : }
14623 : {
14624 66 : resultobj = PyLong_FromLong(result);
14625 : }
14626 : {
14627 66 : Py_XDECREF(encodedInput2);
14628 : }
14629 : return resultobj;
14630 : fail:
14631 : {
14632 0 : Py_XDECREF(encodedInput2);
14633 : }
14634 : return NULL;
14635 : }
14636 :
14637 :
14638 0 : SWIGINTERN PyObject *_wrap_gpgme_key_from_uid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14639 0 : PyObject *resultobj = 0;
14640 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
14641 0 : char *arg2 = (char *) 0 ;
14642 0 : void *argp1 = 0 ;
14643 0 : int res1 = 0 ;
14644 0 : PyObject *encodedInput2 = NULL ;
14645 0 : PyObject * obj0 = 0 ;
14646 0 : PyObject * obj1 = 0 ;
14647 : gpgme_error_t result;
14648 :
14649 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_from_uid",&obj0,&obj1)) SWIG_fail;
14650 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
14651 0 : if (!SWIG_IsOK(res1)) {
14652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_from_uid" "', argument " "1"" of type '" "gpgme_key_t *""'");
14653 : }
14654 0 : arg1 = (gpgme_key_t *)(argp1);
14655 : {
14656 0 : if (obj1 == Py_None)
14657 : arg2 = NULL;
14658 0 : else if (PyUnicode_Check(obj1))
14659 : {
14660 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
14661 0 : if (encodedInput2 == NULL)
14662 : return NULL;
14663 0 : arg2 = PyBytes_AsString(encodedInput2);
14664 : }
14665 0 : else if (PyBytes_Check(obj1))
14666 0 : arg2 = PyBytes_AsString(obj1);
14667 : else {
14668 0 : PyErr_Format(PyExc_TypeError,
14669 : "arg %d: expected str, bytes, or None, got %s",
14670 : 2, obj1->ob_type->tp_name);
14671 0 : return NULL;
14672 : }
14673 : }
14674 : {
14675 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14676 0 : result = gpgme_key_from_uid(arg1,(char const *)arg2);
14677 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14678 : }
14679 : {
14680 0 : resultobj = PyLong_FromLong(result);
14681 : }
14682 : {
14683 0 : Py_XDECREF(encodedInput2);
14684 : }
14685 : return resultobj;
14686 : fail:
14687 : {
14688 : Py_XDECREF(encodedInput2);
14689 : }
14690 : return NULL;
14691 : }
14692 :
14693 :
14694 0 : SWIGINTERN PyObject *_wrap_gpgme_key_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14695 0 : PyObject *resultobj = 0;
14696 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
14697 0 : void *argp1 = 0 ;
14698 0 : int res1 = 0 ;
14699 0 : PyObject * obj0 = 0 ;
14700 :
14701 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_ref",&obj0)) SWIG_fail;
14702 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
14703 0 : if (!SWIG_IsOK(res1)) {
14704 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_ref" "', argument " "1"" of type '" "gpgme_key_t""'");
14705 : }
14706 0 : arg1 = (gpgme_key_t)(argp1);
14707 : {
14708 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14709 0 : gpgme_key_ref(arg1);
14710 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14711 : }
14712 0 : resultobj = SWIG_Py_Void();
14713 0 : return resultobj;
14714 : fail:
14715 : return NULL;
14716 : }
14717 :
14718 :
14719 0 : SWIGINTERN PyObject *_wrap_gpgme_key_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14720 0 : PyObject *resultobj = 0;
14721 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
14722 0 : void *argp1 = 0 ;
14723 0 : int res1 = 0 ;
14724 0 : PyObject * obj0 = 0 ;
14725 :
14726 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_unref",&obj0)) SWIG_fail;
14727 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
14728 0 : if (!SWIG_IsOK(res1)) {
14729 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_unref" "', argument " "1"" of type '" "gpgme_key_t""'");
14730 : }
14731 0 : arg1 = (gpgme_key_t)(argp1);
14732 : {
14733 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14734 0 : gpgme_key_unref(arg1);
14735 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14736 : }
14737 0 : resultobj = SWIG_Py_Void();
14738 0 : return resultobj;
14739 : fail:
14740 : return NULL;
14741 : }
14742 :
14743 :
14744 0 : SWIGINTERN PyObject *_wrap_gpgme_key_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14745 0 : PyObject *resultobj = 0;
14746 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
14747 0 : void *argp1 = 0 ;
14748 0 : int res1 = 0 ;
14749 0 : PyObject * obj0 = 0 ;
14750 :
14751 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_release",&obj0)) SWIG_fail;
14752 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
14753 0 : if (!SWIG_IsOK(res1)) {
14754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_release" "', argument " "1"" of type '" "gpgme_key_t""'");
14755 : }
14756 0 : arg1 = (gpgme_key_t)(argp1);
14757 : {
14758 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14759 0 : gpgme_key_release(arg1);
14760 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14761 : }
14762 0 : resultobj = SWIG_Py_Void();
14763 0 : return resultobj;
14764 : fail:
14765 : return NULL;
14766 : }
14767 :
14768 :
14769 0 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14770 0 : PyObject *resultobj = 0;
14771 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
14772 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
14773 0 : void *argp1 = 0 ;
14774 0 : int res1 = 0 ;
14775 0 : void *argp2 = 0 ;
14776 0 : int res2 = 0 ;
14777 0 : PyObject * obj0 = 0 ;
14778 0 : PyObject * obj1 = 0 ;
14779 :
14780 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_encrypt_result_invalid_recipients_set",&obj0,&obj1)) SWIG_fail;
14781 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
14782 0 : if (!SWIG_IsOK(res1)) {
14783 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_set" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
14784 : }
14785 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
14786 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
14787 0 : if (!SWIG_IsOK(res2)) {
14788 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
14789 : }
14790 0 : arg2 = (gpgme_invalid_key_t)(argp2);
14791 : {
14792 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14793 0 : if (arg1) (arg1)->invalid_recipients = arg2;
14794 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14795 : }
14796 0 : resultobj = SWIG_Py_Void();
14797 0 : return resultobj;
14798 : fail:
14799 : return NULL;
14800 : }
14801 :
14802 :
14803 26 : SWIGINTERN PyObject *_wrap__gpgme_op_encrypt_result_invalid_recipients_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14804 26 : PyObject *resultobj = 0;
14805 26 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
14806 26 : void *argp1 = 0 ;
14807 26 : int res1 = 0 ;
14808 26 : PyObject * obj0 = 0 ;
14809 : gpgme_invalid_key_t result;
14810 :
14811 26 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_encrypt_result_invalid_recipients_get",&obj0)) SWIG_fail;
14812 26 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, 0 | 0 );
14813 26 : if (!SWIG_IsOK(res1)) {
14814 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_encrypt_result_invalid_recipients_get" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
14815 : }
14816 26 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
14817 : {
14818 26 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14819 26 : result = (gpgme_invalid_key_t) ((arg1)->invalid_recipients);
14820 26 : SWIG_PYTHON_THREAD_END_ALLOW;
14821 : }
14822 : {
14823 : int i;
14824 26 : int size = 0;
14825 : gpgme_invalid_key_t curr;
14826 28 : for (curr = result; curr != NULL; curr = curr->next) {
14827 2 : size++;
14828 : }
14829 26 : resultobj = PyList_New(size);
14830 28 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
14831 2 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
14832 2 : PyList_SetItem(resultobj, i, o);
14833 : }
14834 : }
14835 : return resultobj;
14836 : fail:
14837 : return NULL;
14838 : }
14839 :
14840 :
14841 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14842 0 : PyObject *resultobj = 0;
14843 0 : struct _gpgme_op_encrypt_result *result = 0 ;
14844 :
14845 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_encrypt_result")) SWIG_fail;
14846 : {
14847 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14848 0 : result = (struct _gpgme_op_encrypt_result *)calloc(1, sizeof(struct _gpgme_op_encrypt_result));
14849 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14850 : }
14851 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_POINTER_NEW | 0 );
14852 0 : return resultobj;
14853 : fail:
14854 : return NULL;
14855 : }
14856 :
14857 :
14858 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14859 0 : PyObject *resultobj = 0;
14860 0 : struct _gpgme_op_encrypt_result *arg1 = (struct _gpgme_op_encrypt_result *) 0 ;
14861 0 : void *argp1 = 0 ;
14862 0 : int res1 = 0 ;
14863 0 : PyObject * obj0 = 0 ;
14864 :
14865 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_encrypt_result",&obj0)) SWIG_fail;
14866 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_POINTER_DISOWN | 0 );
14867 0 : if (!SWIG_IsOK(res1)) {
14868 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_encrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_encrypt_result *""'");
14869 : }
14870 0 : arg1 = (struct _gpgme_op_encrypt_result *)(argp1);
14871 : {
14872 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14873 0 : free((char *) arg1);
14874 0 : SWIG_PYTHON_THREAD_END_ALLOW;
14875 : }
14876 0 : resultobj = SWIG_Py_Void();
14877 0 : return resultobj;
14878 : fail:
14879 : return NULL;
14880 : }
14881 :
14882 :
14883 27 : SWIGINTERN PyObject *_gpgme_op_encrypt_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14884 : PyObject *obj;
14885 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
14886 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_encrypt_result, SWIG_NewClientData(obj));
14887 27 : return SWIG_Py_Void();
14888 : }
14889 :
14890 13 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14891 13 : PyObject *resultobj = 0;
14892 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
14893 13 : void *argp1 = 0 ;
14894 13 : int res1 = 0 ;
14895 13 : PyObject * obj0 = 0 ;
14896 : gpgme_encrypt_result_t result;
14897 :
14898 13 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_encrypt_result",&obj0)) SWIG_fail;
14899 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
14900 13 : if (!SWIG_IsOK(res1)) {
14901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
14902 : }
14903 13 : arg1 = (gpgme_ctx_t)(argp1);
14904 : {
14905 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
14906 13 : result = (gpgme_encrypt_result_t)gpgme_op_encrypt_result(arg1);
14907 13 : SWIG_PYTHON_THREAD_END_ALLOW;
14908 : }
14909 : {
14910 : PyObject *fragile;
14911 13 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_encrypt_result,
14912 : 0 );
14913 13 : resultobj = _gpg_wrap_result(fragile, "EncryptResult");
14914 13 : Py_DECREF(fragile);
14915 : }
14916 : return resultobj;
14917 : fail:
14918 : return NULL;
14919 : }
14920 :
14921 :
14922 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14923 0 : PyObject *resultobj = 0;
14924 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
14925 : gpgme_key_t *arg2 ;
14926 : gpgme_encrypt_flags_t arg3 ;
14927 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
14928 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
14929 0 : void *argp1 = 0 ;
14930 0 : int res1 = 0 ;
14931 : int val3 ;
14932 0 : int ecode3 = 0 ;
14933 0 : gpgme_data_t wrapper4 = NULL ;
14934 0 : PyObject *bytesio4 = NULL ;
14935 : Py_buffer view4 ;
14936 0 : int have_view4 = 0 ;
14937 0 : gpgme_data_t wrapper5 = NULL ;
14938 0 : PyObject *bytesio5 = NULL ;
14939 : Py_buffer view5 ;
14940 0 : int have_view5 = 0 ;
14941 0 : PyObject * obj0 = 0 ;
14942 0 : PyObject * obj1 = 0 ;
14943 0 : PyObject * obj2 = 0 ;
14944 0 : PyObject * obj3 = 0 ;
14945 0 : PyObject * obj4 = 0 ;
14946 : gpgme_error_t result;
14947 :
14948 : {
14949 0 : arg2 = NULL;
14950 : }
14951 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14952 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
14953 0 : if (!SWIG_IsOK(res1)) {
14954 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
14955 : }
14956 0 : arg1 = (gpgme_ctx_t)(argp1);
14957 : {
14958 0 : int i, numb = 0;
14959 0 : if (!PySequence_Check(obj1)) {
14960 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
14961 : 2);
14962 0 : return NULL;
14963 : }
14964 0 : if((numb = PySequence_Length(obj1)) != 0) {
14965 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
14966 0 : for(i=0; i<numb; i++) {
14967 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
14968 :
14969 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
14970 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
14971 :
14972 : /* Following code is from swig's python.swg. */
14973 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
14974 0 : Py_DECREF(pypointer);
14975 0 : PyErr_Format(PyExc_TypeError,
14976 : "arg %d: list must contain only gpgme_key_ts, got %s "
14977 : "at position %d",
14978 0 : 2, pypointer->ob_type->tp_name, i);
14979 0 : free(arg2);
14980 0 : return NULL;
14981 : }
14982 0 : Py_DECREF(pypointer);
14983 : }
14984 0 : arg2[numb] = NULL;
14985 : }
14986 : }
14987 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
14988 0 : if (!SWIG_IsOK(ecode3)) {
14989 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
14990 : }
14991 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
14992 : {
14993 : /* If we create a temporary wrapper4 object, we will store it in
14994 : wrapperN, where N is 4. Here in this fragment, SWIG will
14995 : automatically append 4. */
14996 0 : memset(&view4, 0, sizeof view4);
14997 0 : if (obj3 == Py_None)
14998 0 : arg4 = NULL;
14999 : else {
15000 : PyObject *pypointer;
15001 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
15002 : &bytesio4, &view4);
15003 0 : if (pypointer == NULL)
15004 : return NULL;
15005 0 : have_view4 = !! view4.obj;
15006 :
15007 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
15008 :
15009 : /* Following code is from swig's python.swg. */
15010 :
15011 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
15012 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15013 0 : Py_DECREF(pypointer);
15014 : return NULL;
15015 : }
15016 0 : Py_DECREF(pypointer);
15017 : }
15018 : }
15019 : {
15020 : /* If we create a temporary wrapper5 object, we will store it in
15021 : wrapperN, where N is 5. Here in this fragment, SWIG will
15022 : automatically append 5. */
15023 0 : memset(&view5, 0, sizeof view5);
15024 0 : if (obj4 == Py_None)
15025 0 : arg5 = NULL;
15026 : else {
15027 : PyObject *pypointer;
15028 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
15029 : &bytesio5, &view5);
15030 0 : if (pypointer == NULL)
15031 : return NULL;
15032 0 : have_view5 = !! view5.obj;
15033 :
15034 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
15035 :
15036 : /* Following code is from swig's python.swg. */
15037 :
15038 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
15039 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15040 0 : Py_DECREF(pypointer);
15041 : return NULL;
15042 : }
15043 0 : Py_DECREF(pypointer);
15044 : }
15045 : }
15046 : {
15047 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15048 0 : result = gpgme_op_encrypt_start(arg1,arg2,arg3,arg4,arg5);
15049 0 : SWIG_PYTHON_THREAD_END_ALLOW;
15050 : }
15051 : {
15052 0 : resultobj = PyLong_FromLong(result);
15053 : }
15054 : {
15055 0 : if (arg2) free(arg2);
15056 : }
15057 : {
15058 : /* See whether we need to update the Python buffer. */
15059 0 : if (resultobj && wrapper4 && view4.buf)
15060 : {
15061 : int dirty;
15062 0 : char *new_data = NULL;
15063 : size_t new_size;
15064 :
15065 :
15066 0 : new_data = wrapper4->data.mem.buffer;
15067 0 : new_size = wrapper4->data.mem.length;
15068 0 : dirty = new_data != NULL;
15069 :
15070 :
15071 :
15072 :
15073 :
15074 :
15075 :
15076 0 : if (dirty)
15077 : {
15078 : /* The buffer is dirty. */
15079 0 : if (view4.readonly)
15080 : {
15081 0 : Py_XDECREF(resultobj);
15082 0 : resultobj = NULL;
15083 0 : PyErr_SetString(PyExc_ValueError,
15084 : "cannot update read-only buffer");
15085 : }
15086 :
15087 : /* See if we need to truncate the buffer. */
15088 0 : if (resultobj && view4.len != new_size)
15089 : {
15090 0 : if (bytesio4 == NULL)
15091 : {
15092 0 : Py_XDECREF(resultobj);
15093 0 : resultobj = NULL;
15094 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15095 : }
15096 : else
15097 : {
15098 : PyObject *retval;
15099 0 : PyBuffer_Release(&view4);
15100 : assert(view4.obj == NULL);
15101 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
15102 : "l", (long) new_size);
15103 0 : if (retval == NULL)
15104 : {
15105 0 : Py_XDECREF(resultobj);
15106 : resultobj = NULL;
15107 : }
15108 : else
15109 : {
15110 0 : Py_DECREF(retval);
15111 :
15112 0 : retval = PyObject_CallMethod(bytesio4,
15113 : "getbuffer", NULL);
15114 0 : if (retval == NULL
15115 0 : || PyObject_GetBuffer(retval, &view4,
15116 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15117 : {
15118 0 : Py_XDECREF(resultobj);
15119 : resultobj = NULL;
15120 : }
15121 :
15122 0 : Py_XDECREF(retval);
15123 :
15124 0 : if (resultobj && view4.len
15125 : != new_size)
15126 : {
15127 0 : Py_XDECREF(resultobj);
15128 0 : resultobj = NULL;
15129 0 : PyErr_Format(PyExc_ValueError,
15130 : "Expected buffer of length %zu, got %zi",
15131 : new_size,
15132 : view4.len);
15133 : }
15134 : }
15135 : }
15136 : }
15137 0 : if (resultobj)
15138 0 : memcpy(view4.buf, new_data, new_size);
15139 : }
15140 :
15141 :
15142 :
15143 : }
15144 :
15145 : /* Free the temporary wrapper, if any. */
15146 0 : if (wrapper4)
15147 0 : gpgme_data_release(wrapper4);
15148 0 : Py_XDECREF (bytesio4);
15149 0 : if (have_view4 && view4.buf)
15150 0 : PyBuffer_Release(&view4);
15151 : }
15152 : {
15153 : /* See whether we need to update the Python buffer. */
15154 0 : if (resultobj && wrapper5 && view5.buf)
15155 : {
15156 : int dirty;
15157 0 : char *new_data = NULL;
15158 : size_t new_size;
15159 :
15160 :
15161 0 : new_data = wrapper5->data.mem.buffer;
15162 0 : new_size = wrapper5->data.mem.length;
15163 0 : dirty = new_data != NULL;
15164 :
15165 :
15166 :
15167 :
15168 :
15169 :
15170 :
15171 0 : if (dirty)
15172 : {
15173 : /* The buffer is dirty. */
15174 0 : if (view5.readonly)
15175 : {
15176 0 : Py_XDECREF(resultobj);
15177 0 : resultobj = NULL;
15178 0 : PyErr_SetString(PyExc_ValueError,
15179 : "cannot update read-only buffer");
15180 : }
15181 :
15182 : /* See if we need to truncate the buffer. */
15183 0 : if (resultobj && view5.len != new_size)
15184 : {
15185 0 : if (bytesio5 == NULL)
15186 : {
15187 0 : Py_XDECREF(resultobj);
15188 0 : resultobj = NULL;
15189 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15190 : }
15191 : else
15192 : {
15193 : PyObject *retval;
15194 0 : PyBuffer_Release(&view5);
15195 : assert(view5.obj == NULL);
15196 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
15197 : "l", (long) new_size);
15198 0 : if (retval == NULL)
15199 : {
15200 0 : Py_XDECREF(resultobj);
15201 : resultobj = NULL;
15202 : }
15203 : else
15204 : {
15205 0 : Py_DECREF(retval);
15206 :
15207 0 : retval = PyObject_CallMethod(bytesio5,
15208 : "getbuffer", NULL);
15209 0 : if (retval == NULL
15210 0 : || PyObject_GetBuffer(retval, &view5,
15211 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15212 : {
15213 0 : Py_XDECREF(resultobj);
15214 : resultobj = NULL;
15215 : }
15216 :
15217 0 : Py_XDECREF(retval);
15218 :
15219 0 : if (resultobj && view5.len
15220 : != new_size)
15221 : {
15222 0 : Py_XDECREF(resultobj);
15223 0 : resultobj = NULL;
15224 0 : PyErr_Format(PyExc_ValueError,
15225 : "Expected buffer of length %zu, got %zi",
15226 : new_size,
15227 : view5.len);
15228 : }
15229 : }
15230 : }
15231 : }
15232 0 : if (resultobj)
15233 0 : memcpy(view5.buf, new_data, new_size);
15234 : }
15235 :
15236 :
15237 :
15238 : }
15239 :
15240 : /* Free the temporary wrapper, if any. */
15241 0 : if (wrapper5)
15242 0 : gpgme_data_release(wrapper5);
15243 0 : Py_XDECREF (bytesio5);
15244 0 : if (have_view5 && view5.buf)
15245 0 : PyBuffer_Release(&view5);
15246 : }
15247 : return resultobj;
15248 : fail:
15249 : {
15250 0 : if (arg2) free(arg2);
15251 : }
15252 : {
15253 : /* See whether we need to update the Python buffer. */
15254 : if (resultobj && wrapper4 && view4.buf)
15255 : {
15256 : int dirty;
15257 : char *new_data = NULL;
15258 : size_t new_size;
15259 :
15260 :
15261 : new_data = wrapper4->data.mem.buffer;
15262 : new_size = wrapper4->data.mem.length;
15263 : dirty = new_data != NULL;
15264 :
15265 :
15266 :
15267 :
15268 :
15269 :
15270 :
15271 : if (dirty)
15272 : {
15273 : /* The buffer is dirty. */
15274 : if (view4.readonly)
15275 : {
15276 : Py_XDECREF(resultobj);
15277 : resultobj = NULL;
15278 : PyErr_SetString(PyExc_ValueError,
15279 : "cannot update read-only buffer");
15280 : }
15281 :
15282 : /* See if we need to truncate the buffer. */
15283 : if (resultobj && view4.len != new_size)
15284 : {
15285 : if (bytesio4 == NULL)
15286 : {
15287 : Py_XDECREF(resultobj);
15288 : resultobj = NULL;
15289 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15290 : }
15291 : else
15292 : {
15293 : PyObject *retval;
15294 : PyBuffer_Release(&view4);
15295 : assert(view4.obj == NULL);
15296 : retval = PyObject_CallMethod(bytesio4, "truncate",
15297 : "l", (long) new_size);
15298 : if (retval == NULL)
15299 : {
15300 : Py_XDECREF(resultobj);
15301 : resultobj = NULL;
15302 : }
15303 : else
15304 : {
15305 : Py_DECREF(retval);
15306 :
15307 : retval = PyObject_CallMethod(bytesio4,
15308 : "getbuffer", NULL);
15309 : if (retval == NULL
15310 : || PyObject_GetBuffer(retval, &view4,
15311 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15312 : {
15313 : Py_XDECREF(resultobj);
15314 : resultobj = NULL;
15315 : }
15316 :
15317 : Py_XDECREF(retval);
15318 :
15319 : if (resultobj && view4.len
15320 : != new_size)
15321 : {
15322 : Py_XDECREF(resultobj);
15323 : resultobj = NULL;
15324 : PyErr_Format(PyExc_ValueError,
15325 : "Expected buffer of length %zu, got %zi",
15326 : new_size,
15327 : view4.len);
15328 : }
15329 : }
15330 : }
15331 : }
15332 : if (resultobj)
15333 : memcpy(view4.buf, new_data, new_size);
15334 : }
15335 :
15336 :
15337 :
15338 : }
15339 :
15340 : /* Free the temporary wrapper, if any. */
15341 0 : if (wrapper4)
15342 0 : gpgme_data_release(wrapper4);
15343 0 : Py_XDECREF (bytesio4);
15344 : if (have_view4 && view4.buf)
15345 : PyBuffer_Release(&view4);
15346 : }
15347 : {
15348 : /* See whether we need to update the Python buffer. */
15349 : if (resultobj && wrapper5 && view5.buf)
15350 : {
15351 : int dirty;
15352 : char *new_data = NULL;
15353 : size_t new_size;
15354 :
15355 :
15356 : new_data = wrapper5->data.mem.buffer;
15357 : new_size = wrapper5->data.mem.length;
15358 : dirty = new_data != NULL;
15359 :
15360 :
15361 :
15362 :
15363 :
15364 :
15365 :
15366 : if (dirty)
15367 : {
15368 : /* The buffer is dirty. */
15369 : if (view5.readonly)
15370 : {
15371 : Py_XDECREF(resultobj);
15372 : resultobj = NULL;
15373 : PyErr_SetString(PyExc_ValueError,
15374 : "cannot update read-only buffer");
15375 : }
15376 :
15377 : /* See if we need to truncate the buffer. */
15378 : if (resultobj && view5.len != new_size)
15379 : {
15380 : if (bytesio5 == NULL)
15381 : {
15382 : Py_XDECREF(resultobj);
15383 : resultobj = NULL;
15384 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15385 : }
15386 : else
15387 : {
15388 : PyObject *retval;
15389 : PyBuffer_Release(&view5);
15390 : assert(view5.obj == NULL);
15391 : retval = PyObject_CallMethod(bytesio5, "truncate",
15392 : "l", (long) new_size);
15393 : if (retval == NULL)
15394 : {
15395 : Py_XDECREF(resultobj);
15396 : resultobj = NULL;
15397 : }
15398 : else
15399 : {
15400 : Py_DECREF(retval);
15401 :
15402 : retval = PyObject_CallMethod(bytesio5,
15403 : "getbuffer", NULL);
15404 : if (retval == NULL
15405 : || PyObject_GetBuffer(retval, &view5,
15406 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15407 : {
15408 : Py_XDECREF(resultobj);
15409 : resultobj = NULL;
15410 : }
15411 :
15412 : Py_XDECREF(retval);
15413 :
15414 : if (resultobj && view5.len
15415 : != new_size)
15416 : {
15417 : Py_XDECREF(resultobj);
15418 : resultobj = NULL;
15419 : PyErr_Format(PyExc_ValueError,
15420 : "Expected buffer of length %zu, got %zi",
15421 : new_size,
15422 : view5.len);
15423 : }
15424 : }
15425 : }
15426 : }
15427 : if (resultobj)
15428 : memcpy(view5.buf, new_data, new_size);
15429 : }
15430 :
15431 :
15432 :
15433 : }
15434 :
15435 : /* Free the temporary wrapper, if any. */
15436 0 : if (wrapper5)
15437 0 : gpgme_data_release(wrapper5);
15438 0 : Py_XDECREF (bytesio5);
15439 : if (have_view5 && view5.buf)
15440 : PyBuffer_Release(&view5);
15441 : }
15442 : return NULL;
15443 : }
15444 :
15445 :
15446 18 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15447 18 : PyObject *resultobj = 0;
15448 18 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15449 : gpgme_key_t *arg2 ;
15450 : gpgme_encrypt_flags_t arg3 ;
15451 18 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
15452 18 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
15453 18 : void *argp1 = 0 ;
15454 18 : int res1 = 0 ;
15455 : int val3 ;
15456 18 : int ecode3 = 0 ;
15457 18 : gpgme_data_t wrapper4 = NULL ;
15458 18 : PyObject *bytesio4 = NULL ;
15459 : Py_buffer view4 ;
15460 18 : int have_view4 = 0 ;
15461 18 : gpgme_data_t wrapper5 = NULL ;
15462 18 : PyObject *bytesio5 = NULL ;
15463 : Py_buffer view5 ;
15464 18 : int have_view5 = 0 ;
15465 18 : PyObject * obj0 = 0 ;
15466 18 : PyObject * obj1 = 0 ;
15467 18 : PyObject * obj2 = 0 ;
15468 18 : PyObject * obj3 = 0 ;
15469 18 : PyObject * obj4 = 0 ;
15470 : gpgme_error_t result;
15471 :
15472 : {
15473 18 : arg2 = NULL;
15474 : }
15475 18 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15476 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
15477 18 : if (!SWIG_IsOK(res1)) {
15478 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
15479 : }
15480 18 : arg1 = (gpgme_ctx_t)(argp1);
15481 : {
15482 18 : int i, numb = 0;
15483 18 : if (!PySequence_Check(obj1)) {
15484 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
15485 : 2);
15486 0 : return NULL;
15487 : }
15488 18 : if((numb = PySequence_Length(obj1)) != 0) {
15489 9 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
15490 22 : for(i=0; i<numb; i++) {
15491 13 : PyObject *pypointer = PySequence_GetItem(obj1, i);
15492 :
15493 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
15494 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
15495 :
15496 : /* Following code is from swig's python.swg. */
15497 13 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15498 0 : Py_DECREF(pypointer);
15499 0 : PyErr_Format(PyExc_TypeError,
15500 : "arg %d: list must contain only gpgme_key_ts, got %s "
15501 : "at position %d",
15502 0 : 2, pypointer->ob_type->tp_name, i);
15503 0 : free(arg2);
15504 0 : return NULL;
15505 : }
15506 13 : Py_DECREF(pypointer);
15507 : }
15508 9 : arg2[numb] = NULL;
15509 : }
15510 : }
15511 36 : ecode3 = SWIG_AsVal_int(obj2, &val3);
15512 18 : if (!SWIG_IsOK(ecode3)) {
15513 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
15514 : }
15515 18 : arg3 = (gpgme_encrypt_flags_t)(val3);
15516 : {
15517 : /* If we create a temporary wrapper4 object, we will store it in
15518 : wrapperN, where N is 4. Here in this fragment, SWIG will
15519 : automatically append 4. */
15520 18 : memset(&view4, 0, sizeof view4);
15521 18 : if (obj3 == Py_None)
15522 0 : arg4 = NULL;
15523 : else {
15524 : PyObject *pypointer;
15525 18 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
15526 : &bytesio4, &view4);
15527 18 : if (pypointer == NULL)
15528 : return NULL;
15529 17 : have_view4 = !! view4.obj;
15530 :
15531 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
15532 :
15533 : /* Following code is from swig's python.swg. */
15534 :
15535 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
15536 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15537 0 : Py_DECREF(pypointer);
15538 : return NULL;
15539 : }
15540 17 : Py_DECREF(pypointer);
15541 : }
15542 : }
15543 : {
15544 : /* If we create a temporary wrapper5 object, we will store it in
15545 : wrapperN, where N is 5. Here in this fragment, SWIG will
15546 : automatically append 5. */
15547 17 : memset(&view5, 0, sizeof view5);
15548 17 : if (obj4 == Py_None)
15549 0 : arg5 = NULL;
15550 : else {
15551 : PyObject *pypointer;
15552 17 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
15553 : &bytesio5, &view5);
15554 17 : if (pypointer == NULL)
15555 : return NULL;
15556 17 : have_view5 = !! view5.obj;
15557 :
15558 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
15559 :
15560 : /* Following code is from swig's python.swg. */
15561 :
15562 17 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
15563 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
15564 0 : Py_DECREF(pypointer);
15565 : return NULL;
15566 : }
15567 17 : Py_DECREF(pypointer);
15568 : }
15569 : }
15570 : {
15571 17 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
15572 17 : result = gpgme_op_encrypt(arg1,arg2,arg3,arg4,arg5);
15573 17 : SWIG_PYTHON_THREAD_END_ALLOW;
15574 : }
15575 : {
15576 17 : resultobj = PyLong_FromLong(result);
15577 : }
15578 : {
15579 17 : if (arg2) free(arg2);
15580 : }
15581 : {
15582 : /* See whether we need to update the Python buffer. */
15583 17 : if (resultobj && wrapper4 && view4.buf)
15584 : {
15585 : int dirty;
15586 5 : char *new_data = NULL;
15587 : size_t new_size;
15588 :
15589 :
15590 5 : new_data = wrapper4->data.mem.buffer;
15591 5 : new_size = wrapper4->data.mem.length;
15592 5 : dirty = new_data != NULL;
15593 :
15594 :
15595 :
15596 :
15597 :
15598 :
15599 :
15600 5 : if (dirty)
15601 : {
15602 : /* The buffer is dirty. */
15603 0 : if (view4.readonly)
15604 : {
15605 0 : Py_XDECREF(resultobj);
15606 0 : resultobj = NULL;
15607 0 : PyErr_SetString(PyExc_ValueError,
15608 : "cannot update read-only buffer");
15609 : }
15610 :
15611 : /* See if we need to truncate the buffer. */
15612 0 : if (resultobj && view4.len != new_size)
15613 : {
15614 0 : if (bytesio4 == NULL)
15615 : {
15616 0 : Py_XDECREF(resultobj);
15617 0 : resultobj = NULL;
15618 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15619 : }
15620 : else
15621 : {
15622 : PyObject *retval;
15623 0 : PyBuffer_Release(&view4);
15624 : assert(view4.obj == NULL);
15625 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
15626 : "l", (long) new_size);
15627 0 : if (retval == NULL)
15628 : {
15629 0 : Py_XDECREF(resultobj);
15630 : resultobj = NULL;
15631 : }
15632 : else
15633 : {
15634 0 : Py_DECREF(retval);
15635 :
15636 0 : retval = PyObject_CallMethod(bytesio4,
15637 : "getbuffer", NULL);
15638 0 : if (retval == NULL
15639 0 : || PyObject_GetBuffer(retval, &view4,
15640 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15641 : {
15642 0 : Py_XDECREF(resultobj);
15643 : resultobj = NULL;
15644 : }
15645 :
15646 0 : Py_XDECREF(retval);
15647 :
15648 0 : if (resultobj && view4.len
15649 : != new_size)
15650 : {
15651 0 : Py_XDECREF(resultobj);
15652 0 : resultobj = NULL;
15653 0 : PyErr_Format(PyExc_ValueError,
15654 : "Expected buffer of length %zu, got %zi",
15655 : new_size,
15656 : view4.len);
15657 : }
15658 : }
15659 : }
15660 : }
15661 0 : if (resultobj)
15662 0 : memcpy(view4.buf, new_data, new_size);
15663 : }
15664 :
15665 :
15666 :
15667 : }
15668 :
15669 : /* Free the temporary wrapper, if any. */
15670 17 : if (wrapper4)
15671 5 : gpgme_data_release(wrapper4);
15672 17 : Py_XDECREF (bytesio4);
15673 17 : if (have_view4 && view4.buf)
15674 5 : PyBuffer_Release(&view4);
15675 : }
15676 : {
15677 : /* See whether we need to update the Python buffer. */
15678 17 : if (resultobj && wrapper5 && view5.buf)
15679 : {
15680 : int dirty;
15681 0 : char *new_data = NULL;
15682 : size_t new_size;
15683 :
15684 :
15685 0 : new_data = wrapper5->data.mem.buffer;
15686 0 : new_size = wrapper5->data.mem.length;
15687 0 : dirty = new_data != NULL;
15688 :
15689 :
15690 :
15691 :
15692 :
15693 :
15694 :
15695 0 : if (dirty)
15696 : {
15697 : /* The buffer is dirty. */
15698 0 : if (view5.readonly)
15699 : {
15700 0 : Py_XDECREF(resultobj);
15701 0 : resultobj = NULL;
15702 0 : PyErr_SetString(PyExc_ValueError,
15703 : "cannot update read-only buffer");
15704 : }
15705 :
15706 : /* See if we need to truncate the buffer. */
15707 0 : if (resultobj && view5.len != new_size)
15708 : {
15709 0 : if (bytesio5 == NULL)
15710 : {
15711 0 : Py_XDECREF(resultobj);
15712 0 : resultobj = NULL;
15713 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15714 : }
15715 : else
15716 : {
15717 : PyObject *retval;
15718 0 : PyBuffer_Release(&view5);
15719 : assert(view5.obj == NULL);
15720 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
15721 : "l", (long) new_size);
15722 0 : if (retval == NULL)
15723 : {
15724 0 : Py_XDECREF(resultobj);
15725 : resultobj = NULL;
15726 : }
15727 : else
15728 : {
15729 0 : Py_DECREF(retval);
15730 :
15731 0 : retval = PyObject_CallMethod(bytesio5,
15732 : "getbuffer", NULL);
15733 0 : if (retval == NULL
15734 0 : || PyObject_GetBuffer(retval, &view5,
15735 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15736 : {
15737 0 : Py_XDECREF(resultobj);
15738 : resultobj = NULL;
15739 : }
15740 :
15741 0 : Py_XDECREF(retval);
15742 :
15743 0 : if (resultobj && view5.len
15744 : != new_size)
15745 : {
15746 0 : Py_XDECREF(resultobj);
15747 0 : resultobj = NULL;
15748 0 : PyErr_Format(PyExc_ValueError,
15749 : "Expected buffer of length %zu, got %zi",
15750 : new_size,
15751 : view5.len);
15752 : }
15753 : }
15754 : }
15755 : }
15756 0 : if (resultobj)
15757 0 : memcpy(view5.buf, new_data, new_size);
15758 : }
15759 :
15760 :
15761 :
15762 : }
15763 :
15764 : /* Free the temporary wrapper, if any. */
15765 17 : if (wrapper5)
15766 0 : gpgme_data_release(wrapper5);
15767 17 : Py_XDECREF (bytesio5);
15768 17 : if (have_view5 && view5.buf)
15769 0 : PyBuffer_Release(&view5);
15770 : }
15771 : return resultobj;
15772 : fail:
15773 : {
15774 0 : if (arg2) free(arg2);
15775 : }
15776 : {
15777 : /* See whether we need to update the Python buffer. */
15778 : if (resultobj && wrapper4 && view4.buf)
15779 : {
15780 : int dirty;
15781 : char *new_data = NULL;
15782 : size_t new_size;
15783 :
15784 :
15785 : new_data = wrapper4->data.mem.buffer;
15786 : new_size = wrapper4->data.mem.length;
15787 : dirty = new_data != NULL;
15788 :
15789 :
15790 :
15791 :
15792 :
15793 :
15794 :
15795 : if (dirty)
15796 : {
15797 : /* The buffer is dirty. */
15798 : if (view4.readonly)
15799 : {
15800 : Py_XDECREF(resultobj);
15801 : resultobj = NULL;
15802 : PyErr_SetString(PyExc_ValueError,
15803 : "cannot update read-only buffer");
15804 : }
15805 :
15806 : /* See if we need to truncate the buffer. */
15807 : if (resultobj && view4.len != new_size)
15808 : {
15809 : if (bytesio4 == NULL)
15810 : {
15811 : Py_XDECREF(resultobj);
15812 : resultobj = NULL;
15813 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15814 : }
15815 : else
15816 : {
15817 : PyObject *retval;
15818 : PyBuffer_Release(&view4);
15819 : assert(view4.obj == NULL);
15820 : retval = PyObject_CallMethod(bytesio4, "truncate",
15821 : "l", (long) new_size);
15822 : if (retval == NULL)
15823 : {
15824 : Py_XDECREF(resultobj);
15825 : resultobj = NULL;
15826 : }
15827 : else
15828 : {
15829 : Py_DECREF(retval);
15830 :
15831 : retval = PyObject_CallMethod(bytesio4,
15832 : "getbuffer", NULL);
15833 : if (retval == NULL
15834 : || PyObject_GetBuffer(retval, &view4,
15835 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15836 : {
15837 : Py_XDECREF(resultobj);
15838 : resultobj = NULL;
15839 : }
15840 :
15841 : Py_XDECREF(retval);
15842 :
15843 : if (resultobj && view4.len
15844 : != new_size)
15845 : {
15846 : Py_XDECREF(resultobj);
15847 : resultobj = NULL;
15848 : PyErr_Format(PyExc_ValueError,
15849 : "Expected buffer of length %zu, got %zi",
15850 : new_size,
15851 : view4.len);
15852 : }
15853 : }
15854 : }
15855 : }
15856 : if (resultobj)
15857 : memcpy(view4.buf, new_data, new_size);
15858 : }
15859 :
15860 :
15861 :
15862 : }
15863 :
15864 : /* Free the temporary wrapper, if any. */
15865 0 : if (wrapper4)
15866 0 : gpgme_data_release(wrapper4);
15867 0 : Py_XDECREF (bytesio4);
15868 : if (have_view4 && view4.buf)
15869 : PyBuffer_Release(&view4);
15870 : }
15871 : {
15872 : /* See whether we need to update the Python buffer. */
15873 : if (resultobj && wrapper5 && view5.buf)
15874 : {
15875 : int dirty;
15876 : char *new_data = NULL;
15877 : size_t new_size;
15878 :
15879 :
15880 : new_data = wrapper5->data.mem.buffer;
15881 : new_size = wrapper5->data.mem.length;
15882 : dirty = new_data != NULL;
15883 :
15884 :
15885 :
15886 :
15887 :
15888 :
15889 :
15890 : if (dirty)
15891 : {
15892 : /* The buffer is dirty. */
15893 : if (view5.readonly)
15894 : {
15895 : Py_XDECREF(resultobj);
15896 : resultobj = NULL;
15897 : PyErr_SetString(PyExc_ValueError,
15898 : "cannot update read-only buffer");
15899 : }
15900 :
15901 : /* See if we need to truncate the buffer. */
15902 : if (resultobj && view5.len != new_size)
15903 : {
15904 : if (bytesio5 == NULL)
15905 : {
15906 : Py_XDECREF(resultobj);
15907 : resultobj = NULL;
15908 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
15909 : }
15910 : else
15911 : {
15912 : PyObject *retval;
15913 : PyBuffer_Release(&view5);
15914 : assert(view5.obj == NULL);
15915 : retval = PyObject_CallMethod(bytesio5, "truncate",
15916 : "l", (long) new_size);
15917 : if (retval == NULL)
15918 : {
15919 : Py_XDECREF(resultobj);
15920 : resultobj = NULL;
15921 : }
15922 : else
15923 : {
15924 : Py_DECREF(retval);
15925 :
15926 : retval = PyObject_CallMethod(bytesio5,
15927 : "getbuffer", NULL);
15928 : if (retval == NULL
15929 : || PyObject_GetBuffer(retval, &view5,
15930 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
15931 : {
15932 : Py_XDECREF(resultobj);
15933 : resultobj = NULL;
15934 : }
15935 :
15936 : Py_XDECREF(retval);
15937 :
15938 : if (resultobj && view5.len
15939 : != new_size)
15940 : {
15941 : Py_XDECREF(resultobj);
15942 : resultobj = NULL;
15943 : PyErr_Format(PyExc_ValueError,
15944 : "Expected buffer of length %zu, got %zi",
15945 : new_size,
15946 : view5.len);
15947 : }
15948 : }
15949 : }
15950 : }
15951 : if (resultobj)
15952 : memcpy(view5.buf, new_data, new_size);
15953 : }
15954 :
15955 :
15956 :
15957 : }
15958 :
15959 : /* Free the temporary wrapper, if any. */
15960 0 : if (wrapper5)
15961 0 : gpgme_data_release(wrapper5);
15962 0 : Py_XDECREF (bytesio5);
15963 : if (have_view5 && view5.buf)
15964 : PyBuffer_Release(&view5);
15965 : }
15966 : return NULL;
15967 : }
15968 :
15969 :
15970 0 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15971 0 : PyObject *resultobj = 0;
15972 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
15973 : gpgme_key_t *arg2 ;
15974 : gpgme_encrypt_flags_t arg3 ;
15975 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
15976 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
15977 0 : void *argp1 = 0 ;
15978 0 : int res1 = 0 ;
15979 : int val3 ;
15980 0 : int ecode3 = 0 ;
15981 0 : gpgme_data_t wrapper4 = NULL ;
15982 0 : PyObject *bytesio4 = NULL ;
15983 : Py_buffer view4 ;
15984 0 : int have_view4 = 0 ;
15985 0 : gpgme_data_t wrapper5 = NULL ;
15986 0 : PyObject *bytesio5 = NULL ;
15987 : Py_buffer view5 ;
15988 0 : int have_view5 = 0 ;
15989 0 : PyObject * obj0 = 0 ;
15990 0 : PyObject * obj1 = 0 ;
15991 0 : PyObject * obj2 = 0 ;
15992 0 : PyObject * obj3 = 0 ;
15993 0 : PyObject * obj4 = 0 ;
15994 : gpgme_error_t result;
15995 :
15996 : {
15997 0 : arg2 = NULL;
15998 : }
15999 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16000 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16001 0 : if (!SWIG_IsOK(res1)) {
16002 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16003 : }
16004 0 : arg1 = (gpgme_ctx_t)(argp1);
16005 : {
16006 0 : int i, numb = 0;
16007 0 : if (!PySequence_Check(obj1)) {
16008 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
16009 : 2);
16010 0 : return NULL;
16011 : }
16012 0 : if((numb = PySequence_Length(obj1)) != 0) {
16013 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
16014 0 : for(i=0; i<numb; i++) {
16015 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
16016 :
16017 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
16018 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
16019 :
16020 : /* Following code is from swig's python.swg. */
16021 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16022 0 : Py_DECREF(pypointer);
16023 0 : PyErr_Format(PyExc_TypeError,
16024 : "arg %d: list must contain only gpgme_key_ts, got %s "
16025 : "at position %d",
16026 0 : 2, pypointer->ob_type->tp_name, i);
16027 0 : free(arg2);
16028 0 : return NULL;
16029 : }
16030 0 : Py_DECREF(pypointer);
16031 : }
16032 0 : arg2[numb] = NULL;
16033 : }
16034 : }
16035 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
16036 0 : if (!SWIG_IsOK(ecode3)) {
16037 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign_start" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
16038 : }
16039 0 : arg3 = (gpgme_encrypt_flags_t)(val3);
16040 : {
16041 : /* If we create a temporary wrapper4 object, we will store it in
16042 : wrapperN, where N is 4. Here in this fragment, SWIG will
16043 : automatically append 4. */
16044 0 : memset(&view4, 0, sizeof view4);
16045 0 : if (obj3 == Py_None)
16046 0 : arg4 = NULL;
16047 : else {
16048 : PyObject *pypointer;
16049 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
16050 : &bytesio4, &view4);
16051 0 : if (pypointer == NULL)
16052 : return NULL;
16053 0 : have_view4 = !! view4.obj;
16054 :
16055 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
16056 :
16057 : /* Following code is from swig's python.swg. */
16058 :
16059 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
16060 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16061 0 : Py_DECREF(pypointer);
16062 : return NULL;
16063 : }
16064 0 : Py_DECREF(pypointer);
16065 : }
16066 : }
16067 : {
16068 : /* If we create a temporary wrapper5 object, we will store it in
16069 : wrapperN, where N is 5. Here in this fragment, SWIG will
16070 : automatically append 5. */
16071 0 : memset(&view5, 0, sizeof view5);
16072 0 : if (obj4 == Py_None)
16073 0 : arg5 = NULL;
16074 : else {
16075 : PyObject *pypointer;
16076 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
16077 : &bytesio5, &view5);
16078 0 : if (pypointer == NULL)
16079 : return NULL;
16080 0 : have_view5 = !! view5.obj;
16081 :
16082 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
16083 :
16084 : /* Following code is from swig's python.swg. */
16085 :
16086 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
16087 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16088 0 : Py_DECREF(pypointer);
16089 : return NULL;
16090 : }
16091 0 : Py_DECREF(pypointer);
16092 : }
16093 : }
16094 : {
16095 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16096 0 : result = gpgme_op_encrypt_sign_start(arg1,arg2,arg3,arg4,arg5);
16097 0 : SWIG_PYTHON_THREAD_END_ALLOW;
16098 : }
16099 : {
16100 0 : resultobj = PyLong_FromLong(result);
16101 : }
16102 : {
16103 0 : if (arg2) free(arg2);
16104 : }
16105 : {
16106 : /* See whether we need to update the Python buffer. */
16107 0 : if (resultobj && wrapper4 && view4.buf)
16108 : {
16109 : int dirty;
16110 0 : char *new_data = NULL;
16111 : size_t new_size;
16112 :
16113 :
16114 0 : new_data = wrapper4->data.mem.buffer;
16115 0 : new_size = wrapper4->data.mem.length;
16116 0 : dirty = new_data != NULL;
16117 :
16118 :
16119 :
16120 :
16121 :
16122 :
16123 :
16124 0 : if (dirty)
16125 : {
16126 : /* The buffer is dirty. */
16127 0 : if (view4.readonly)
16128 : {
16129 0 : Py_XDECREF(resultobj);
16130 0 : resultobj = NULL;
16131 0 : PyErr_SetString(PyExc_ValueError,
16132 : "cannot update read-only buffer");
16133 : }
16134 :
16135 : /* See if we need to truncate the buffer. */
16136 0 : if (resultobj && view4.len != new_size)
16137 : {
16138 0 : if (bytesio4 == NULL)
16139 : {
16140 0 : Py_XDECREF(resultobj);
16141 0 : resultobj = NULL;
16142 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16143 : }
16144 : else
16145 : {
16146 : PyObject *retval;
16147 0 : PyBuffer_Release(&view4);
16148 : assert(view4.obj == NULL);
16149 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
16150 : "l", (long) new_size);
16151 0 : if (retval == NULL)
16152 : {
16153 0 : Py_XDECREF(resultobj);
16154 : resultobj = NULL;
16155 : }
16156 : else
16157 : {
16158 0 : Py_DECREF(retval);
16159 :
16160 0 : retval = PyObject_CallMethod(bytesio4,
16161 : "getbuffer", NULL);
16162 0 : if (retval == NULL
16163 0 : || PyObject_GetBuffer(retval, &view4,
16164 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16165 : {
16166 0 : Py_XDECREF(resultobj);
16167 : resultobj = NULL;
16168 : }
16169 :
16170 0 : Py_XDECREF(retval);
16171 :
16172 0 : if (resultobj && view4.len
16173 : != new_size)
16174 : {
16175 0 : Py_XDECREF(resultobj);
16176 0 : resultobj = NULL;
16177 0 : PyErr_Format(PyExc_ValueError,
16178 : "Expected buffer of length %zu, got %zi",
16179 : new_size,
16180 : view4.len);
16181 : }
16182 : }
16183 : }
16184 : }
16185 0 : if (resultobj)
16186 0 : memcpy(view4.buf, new_data, new_size);
16187 : }
16188 :
16189 :
16190 :
16191 : }
16192 :
16193 : /* Free the temporary wrapper, if any. */
16194 0 : if (wrapper4)
16195 0 : gpgme_data_release(wrapper4);
16196 0 : Py_XDECREF (bytesio4);
16197 0 : if (have_view4 && view4.buf)
16198 0 : PyBuffer_Release(&view4);
16199 : }
16200 : {
16201 : /* See whether we need to update the Python buffer. */
16202 0 : if (resultobj && wrapper5 && view5.buf)
16203 : {
16204 : int dirty;
16205 0 : char *new_data = NULL;
16206 : size_t new_size;
16207 :
16208 :
16209 0 : new_data = wrapper5->data.mem.buffer;
16210 0 : new_size = wrapper5->data.mem.length;
16211 0 : dirty = new_data != NULL;
16212 :
16213 :
16214 :
16215 :
16216 :
16217 :
16218 :
16219 0 : if (dirty)
16220 : {
16221 : /* The buffer is dirty. */
16222 0 : if (view5.readonly)
16223 : {
16224 0 : Py_XDECREF(resultobj);
16225 0 : resultobj = NULL;
16226 0 : PyErr_SetString(PyExc_ValueError,
16227 : "cannot update read-only buffer");
16228 : }
16229 :
16230 : /* See if we need to truncate the buffer. */
16231 0 : if (resultobj && view5.len != new_size)
16232 : {
16233 0 : if (bytesio5 == NULL)
16234 : {
16235 0 : Py_XDECREF(resultobj);
16236 0 : resultobj = NULL;
16237 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16238 : }
16239 : else
16240 : {
16241 : PyObject *retval;
16242 0 : PyBuffer_Release(&view5);
16243 : assert(view5.obj == NULL);
16244 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
16245 : "l", (long) new_size);
16246 0 : if (retval == NULL)
16247 : {
16248 0 : Py_XDECREF(resultobj);
16249 : resultobj = NULL;
16250 : }
16251 : else
16252 : {
16253 0 : Py_DECREF(retval);
16254 :
16255 0 : retval = PyObject_CallMethod(bytesio5,
16256 : "getbuffer", NULL);
16257 0 : if (retval == NULL
16258 0 : || PyObject_GetBuffer(retval, &view5,
16259 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16260 : {
16261 0 : Py_XDECREF(resultobj);
16262 : resultobj = NULL;
16263 : }
16264 :
16265 0 : Py_XDECREF(retval);
16266 :
16267 0 : if (resultobj && view5.len
16268 : != new_size)
16269 : {
16270 0 : Py_XDECREF(resultobj);
16271 0 : resultobj = NULL;
16272 0 : PyErr_Format(PyExc_ValueError,
16273 : "Expected buffer of length %zu, got %zi",
16274 : new_size,
16275 : view5.len);
16276 : }
16277 : }
16278 : }
16279 : }
16280 0 : if (resultobj)
16281 0 : memcpy(view5.buf, new_data, new_size);
16282 : }
16283 :
16284 :
16285 :
16286 : }
16287 :
16288 : /* Free the temporary wrapper, if any. */
16289 0 : if (wrapper5)
16290 0 : gpgme_data_release(wrapper5);
16291 0 : Py_XDECREF (bytesio5);
16292 0 : if (have_view5 && view5.buf)
16293 0 : PyBuffer_Release(&view5);
16294 : }
16295 : return resultobj;
16296 : fail:
16297 : {
16298 0 : if (arg2) free(arg2);
16299 : }
16300 : {
16301 : /* See whether we need to update the Python buffer. */
16302 : if (resultobj && wrapper4 && view4.buf)
16303 : {
16304 : int dirty;
16305 : char *new_data = NULL;
16306 : size_t new_size;
16307 :
16308 :
16309 : new_data = wrapper4->data.mem.buffer;
16310 : new_size = wrapper4->data.mem.length;
16311 : dirty = new_data != NULL;
16312 :
16313 :
16314 :
16315 :
16316 :
16317 :
16318 :
16319 : if (dirty)
16320 : {
16321 : /* The buffer is dirty. */
16322 : if (view4.readonly)
16323 : {
16324 : Py_XDECREF(resultobj);
16325 : resultobj = NULL;
16326 : PyErr_SetString(PyExc_ValueError,
16327 : "cannot update read-only buffer");
16328 : }
16329 :
16330 : /* See if we need to truncate the buffer. */
16331 : if (resultobj && view4.len != new_size)
16332 : {
16333 : if (bytesio4 == NULL)
16334 : {
16335 : Py_XDECREF(resultobj);
16336 : resultobj = NULL;
16337 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16338 : }
16339 : else
16340 : {
16341 : PyObject *retval;
16342 : PyBuffer_Release(&view4);
16343 : assert(view4.obj == NULL);
16344 : retval = PyObject_CallMethod(bytesio4, "truncate",
16345 : "l", (long) new_size);
16346 : if (retval == NULL)
16347 : {
16348 : Py_XDECREF(resultobj);
16349 : resultobj = NULL;
16350 : }
16351 : else
16352 : {
16353 : Py_DECREF(retval);
16354 :
16355 : retval = PyObject_CallMethod(bytesio4,
16356 : "getbuffer", NULL);
16357 : if (retval == NULL
16358 : || PyObject_GetBuffer(retval, &view4,
16359 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16360 : {
16361 : Py_XDECREF(resultobj);
16362 : resultobj = NULL;
16363 : }
16364 :
16365 : Py_XDECREF(retval);
16366 :
16367 : if (resultobj && view4.len
16368 : != new_size)
16369 : {
16370 : Py_XDECREF(resultobj);
16371 : resultobj = NULL;
16372 : PyErr_Format(PyExc_ValueError,
16373 : "Expected buffer of length %zu, got %zi",
16374 : new_size,
16375 : view4.len);
16376 : }
16377 : }
16378 : }
16379 : }
16380 : if (resultobj)
16381 : memcpy(view4.buf, new_data, new_size);
16382 : }
16383 :
16384 :
16385 :
16386 : }
16387 :
16388 : /* Free the temporary wrapper, if any. */
16389 0 : if (wrapper4)
16390 0 : gpgme_data_release(wrapper4);
16391 0 : Py_XDECREF (bytesio4);
16392 : if (have_view4 && view4.buf)
16393 : PyBuffer_Release(&view4);
16394 : }
16395 : {
16396 : /* See whether we need to update the Python buffer. */
16397 : if (resultobj && wrapper5 && view5.buf)
16398 : {
16399 : int dirty;
16400 : char *new_data = NULL;
16401 : size_t new_size;
16402 :
16403 :
16404 : new_data = wrapper5->data.mem.buffer;
16405 : new_size = wrapper5->data.mem.length;
16406 : dirty = new_data != NULL;
16407 :
16408 :
16409 :
16410 :
16411 :
16412 :
16413 :
16414 : if (dirty)
16415 : {
16416 : /* The buffer is dirty. */
16417 : if (view5.readonly)
16418 : {
16419 : Py_XDECREF(resultobj);
16420 : resultobj = NULL;
16421 : PyErr_SetString(PyExc_ValueError,
16422 : "cannot update read-only buffer");
16423 : }
16424 :
16425 : /* See if we need to truncate the buffer. */
16426 : if (resultobj && view5.len != new_size)
16427 : {
16428 : if (bytesio5 == NULL)
16429 : {
16430 : Py_XDECREF(resultobj);
16431 : resultobj = NULL;
16432 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16433 : }
16434 : else
16435 : {
16436 : PyObject *retval;
16437 : PyBuffer_Release(&view5);
16438 : assert(view5.obj == NULL);
16439 : retval = PyObject_CallMethod(bytesio5, "truncate",
16440 : "l", (long) new_size);
16441 : if (retval == NULL)
16442 : {
16443 : Py_XDECREF(resultobj);
16444 : resultobj = NULL;
16445 : }
16446 : else
16447 : {
16448 : Py_DECREF(retval);
16449 :
16450 : retval = PyObject_CallMethod(bytesio5,
16451 : "getbuffer", NULL);
16452 : if (retval == NULL
16453 : || PyObject_GetBuffer(retval, &view5,
16454 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16455 : {
16456 : Py_XDECREF(resultobj);
16457 : resultobj = NULL;
16458 : }
16459 :
16460 : Py_XDECREF(retval);
16461 :
16462 : if (resultobj && view5.len
16463 : != new_size)
16464 : {
16465 : Py_XDECREF(resultobj);
16466 : resultobj = NULL;
16467 : PyErr_Format(PyExc_ValueError,
16468 : "Expected buffer of length %zu, got %zi",
16469 : new_size,
16470 : view5.len);
16471 : }
16472 : }
16473 : }
16474 : }
16475 : if (resultobj)
16476 : memcpy(view5.buf, new_data, new_size);
16477 : }
16478 :
16479 :
16480 :
16481 : }
16482 :
16483 : /* Free the temporary wrapper, if any. */
16484 0 : if (wrapper5)
16485 0 : gpgme_data_release(wrapper5);
16486 0 : Py_XDECREF (bytesio5);
16487 : if (have_view5 && view5.buf)
16488 : PyBuffer_Release(&view5);
16489 : }
16490 : return NULL;
16491 : }
16492 :
16493 :
16494 7 : SWIGINTERN PyObject *_wrap_gpgme_op_encrypt_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16495 7 : PyObject *resultobj = 0;
16496 7 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
16497 : gpgme_key_t *arg2 ;
16498 : gpgme_encrypt_flags_t arg3 ;
16499 7 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
16500 7 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
16501 7 : void *argp1 = 0 ;
16502 7 : int res1 = 0 ;
16503 : int val3 ;
16504 7 : int ecode3 = 0 ;
16505 7 : gpgme_data_t wrapper4 = NULL ;
16506 7 : PyObject *bytesio4 = NULL ;
16507 : Py_buffer view4 ;
16508 7 : int have_view4 = 0 ;
16509 7 : gpgme_data_t wrapper5 = NULL ;
16510 7 : PyObject *bytesio5 = NULL ;
16511 : Py_buffer view5 ;
16512 7 : int have_view5 = 0 ;
16513 7 : PyObject * obj0 = 0 ;
16514 7 : PyObject * obj1 = 0 ;
16515 7 : PyObject * obj2 = 0 ;
16516 7 : PyObject * obj3 = 0 ;
16517 7 : PyObject * obj4 = 0 ;
16518 : gpgme_error_t result;
16519 :
16520 : {
16521 7 : arg2 = NULL;
16522 : }
16523 7 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_encrypt_sign",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16524 7 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
16525 7 : if (!SWIG_IsOK(res1)) {
16526 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_encrypt_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
16527 : }
16528 7 : arg1 = (gpgme_ctx_t)(argp1);
16529 : {
16530 7 : int i, numb = 0;
16531 7 : if (!PySequence_Check(obj1)) {
16532 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
16533 : 2);
16534 0 : return NULL;
16535 : }
16536 7 : if((numb = PySequence_Length(obj1)) != 0) {
16537 6 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
16538 16 : for(i=0; i<numb; i++) {
16539 10 : PyObject *pypointer = PySequence_GetItem(obj1, i);
16540 :
16541 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
16542 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
16543 :
16544 : /* Following code is from swig's python.swg. */
16545 10 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16546 0 : Py_DECREF(pypointer);
16547 0 : PyErr_Format(PyExc_TypeError,
16548 : "arg %d: list must contain only gpgme_key_ts, got %s "
16549 : "at position %d",
16550 0 : 2, pypointer->ob_type->tp_name, i);
16551 0 : free(arg2);
16552 0 : return NULL;
16553 : }
16554 10 : Py_DECREF(pypointer);
16555 : }
16556 6 : arg2[numb] = NULL;
16557 : }
16558 : }
16559 14 : ecode3 = SWIG_AsVal_int(obj2, &val3);
16560 7 : if (!SWIG_IsOK(ecode3)) {
16561 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_encrypt_sign" "', argument " "3"" of type '" "gpgme_encrypt_flags_t""'");
16562 : }
16563 7 : arg3 = (gpgme_encrypt_flags_t)(val3);
16564 : {
16565 : /* If we create a temporary wrapper4 object, we will store it in
16566 : wrapperN, where N is 4. Here in this fragment, SWIG will
16567 : automatically append 4. */
16568 7 : memset(&view4, 0, sizeof view4);
16569 7 : if (obj3 == Py_None)
16570 0 : arg4 = NULL;
16571 : else {
16572 : PyObject *pypointer;
16573 7 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
16574 : &bytesio4, &view4);
16575 7 : if (pypointer == NULL)
16576 : return NULL;
16577 7 : have_view4 = !! view4.obj;
16578 :
16579 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
16580 :
16581 : /* Following code is from swig's python.swg. */
16582 :
16583 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
16584 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16585 0 : Py_DECREF(pypointer);
16586 : return NULL;
16587 : }
16588 7 : Py_DECREF(pypointer);
16589 : }
16590 : }
16591 : {
16592 : /* If we create a temporary wrapper5 object, we will store it in
16593 : wrapperN, where N is 5. Here in this fragment, SWIG will
16594 : automatically append 5. */
16595 7 : memset(&view5, 0, sizeof view5);
16596 7 : if (obj4 == Py_None)
16597 0 : arg5 = NULL;
16598 : else {
16599 : PyObject *pypointer;
16600 7 : pypointer = _gpg_obj2gpgme_data_t(obj4, 5, &wrapper5,
16601 : &bytesio5, &view5);
16602 7 : if (pypointer == NULL)
16603 : return NULL;
16604 7 : have_view5 = !! view5.obj;
16605 :
16606 : /* input = obj4, 1 = arg5, 1_descriptor = SWIGTYPE_p_gpgme_data */
16607 :
16608 : /* Following code is from swig's python.swg. */
16609 :
16610 7 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg5, SWIGTYPE_p_gpgme_data,
16611 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
16612 0 : Py_DECREF(pypointer);
16613 : return NULL;
16614 : }
16615 7 : Py_DECREF(pypointer);
16616 : }
16617 : }
16618 : {
16619 7 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
16620 7 : result = gpgme_op_encrypt_sign(arg1,arg2,arg3,arg4,arg5);
16621 7 : SWIG_PYTHON_THREAD_END_ALLOW;
16622 : }
16623 : {
16624 7 : resultobj = PyLong_FromLong(result);
16625 : }
16626 : {
16627 7 : if (arg2) free(arg2);
16628 : }
16629 : {
16630 : /* See whether we need to update the Python buffer. */
16631 7 : if (resultobj && wrapper4 && view4.buf)
16632 : {
16633 : int dirty;
16634 5 : char *new_data = NULL;
16635 : size_t new_size;
16636 :
16637 :
16638 5 : new_data = wrapper4->data.mem.buffer;
16639 5 : new_size = wrapper4->data.mem.length;
16640 5 : dirty = new_data != NULL;
16641 :
16642 :
16643 :
16644 :
16645 :
16646 :
16647 :
16648 5 : if (dirty)
16649 : {
16650 : /* The buffer is dirty. */
16651 0 : if (view4.readonly)
16652 : {
16653 0 : Py_XDECREF(resultobj);
16654 0 : resultobj = NULL;
16655 0 : PyErr_SetString(PyExc_ValueError,
16656 : "cannot update read-only buffer");
16657 : }
16658 :
16659 : /* See if we need to truncate the buffer. */
16660 0 : if (resultobj && view4.len != new_size)
16661 : {
16662 0 : if (bytesio4 == NULL)
16663 : {
16664 0 : Py_XDECREF(resultobj);
16665 0 : resultobj = NULL;
16666 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16667 : }
16668 : else
16669 : {
16670 : PyObject *retval;
16671 0 : PyBuffer_Release(&view4);
16672 : assert(view4.obj == NULL);
16673 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
16674 : "l", (long) new_size);
16675 0 : if (retval == NULL)
16676 : {
16677 0 : Py_XDECREF(resultobj);
16678 : resultobj = NULL;
16679 : }
16680 : else
16681 : {
16682 0 : Py_DECREF(retval);
16683 :
16684 0 : retval = PyObject_CallMethod(bytesio4,
16685 : "getbuffer", NULL);
16686 0 : if (retval == NULL
16687 0 : || PyObject_GetBuffer(retval, &view4,
16688 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16689 : {
16690 0 : Py_XDECREF(resultobj);
16691 : resultobj = NULL;
16692 : }
16693 :
16694 0 : Py_XDECREF(retval);
16695 :
16696 0 : if (resultobj && view4.len
16697 : != new_size)
16698 : {
16699 0 : Py_XDECREF(resultobj);
16700 0 : resultobj = NULL;
16701 0 : PyErr_Format(PyExc_ValueError,
16702 : "Expected buffer of length %zu, got %zi",
16703 : new_size,
16704 : view4.len);
16705 : }
16706 : }
16707 : }
16708 : }
16709 0 : if (resultobj)
16710 0 : memcpy(view4.buf, new_data, new_size);
16711 : }
16712 :
16713 :
16714 :
16715 : }
16716 :
16717 : /* Free the temporary wrapper, if any. */
16718 7 : if (wrapper4)
16719 5 : gpgme_data_release(wrapper4);
16720 7 : Py_XDECREF (bytesio4);
16721 7 : if (have_view4 && view4.buf)
16722 5 : PyBuffer_Release(&view4);
16723 : }
16724 : {
16725 : /* See whether we need to update the Python buffer. */
16726 7 : if (resultobj && wrapper5 && view5.buf)
16727 : {
16728 : int dirty;
16729 0 : char *new_data = NULL;
16730 : size_t new_size;
16731 :
16732 :
16733 0 : new_data = wrapper5->data.mem.buffer;
16734 0 : new_size = wrapper5->data.mem.length;
16735 0 : dirty = new_data != NULL;
16736 :
16737 :
16738 :
16739 :
16740 :
16741 :
16742 :
16743 0 : if (dirty)
16744 : {
16745 : /* The buffer is dirty. */
16746 0 : if (view5.readonly)
16747 : {
16748 0 : Py_XDECREF(resultobj);
16749 0 : resultobj = NULL;
16750 0 : PyErr_SetString(PyExc_ValueError,
16751 : "cannot update read-only buffer");
16752 : }
16753 :
16754 : /* See if we need to truncate the buffer. */
16755 0 : if (resultobj && view5.len != new_size)
16756 : {
16757 0 : if (bytesio5 == NULL)
16758 : {
16759 0 : Py_XDECREF(resultobj);
16760 0 : resultobj = NULL;
16761 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16762 : }
16763 : else
16764 : {
16765 : PyObject *retval;
16766 0 : PyBuffer_Release(&view5);
16767 : assert(view5.obj == NULL);
16768 0 : retval = PyObject_CallMethod(bytesio5, "truncate",
16769 : "l", (long) new_size);
16770 0 : if (retval == NULL)
16771 : {
16772 0 : Py_XDECREF(resultobj);
16773 : resultobj = NULL;
16774 : }
16775 : else
16776 : {
16777 0 : Py_DECREF(retval);
16778 :
16779 0 : retval = PyObject_CallMethod(bytesio5,
16780 : "getbuffer", NULL);
16781 0 : if (retval == NULL
16782 0 : || PyObject_GetBuffer(retval, &view5,
16783 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16784 : {
16785 0 : Py_XDECREF(resultobj);
16786 : resultobj = NULL;
16787 : }
16788 :
16789 0 : Py_XDECREF(retval);
16790 :
16791 0 : if (resultobj && view5.len
16792 : != new_size)
16793 : {
16794 0 : Py_XDECREF(resultobj);
16795 0 : resultobj = NULL;
16796 0 : PyErr_Format(PyExc_ValueError,
16797 : "Expected buffer of length %zu, got %zi",
16798 : new_size,
16799 : view5.len);
16800 : }
16801 : }
16802 : }
16803 : }
16804 0 : if (resultobj)
16805 0 : memcpy(view5.buf, new_data, new_size);
16806 : }
16807 :
16808 :
16809 :
16810 : }
16811 :
16812 : /* Free the temporary wrapper, if any. */
16813 7 : if (wrapper5)
16814 0 : gpgme_data_release(wrapper5);
16815 7 : Py_XDECREF (bytesio5);
16816 7 : if (have_view5 && view5.buf)
16817 0 : PyBuffer_Release(&view5);
16818 : }
16819 : return resultobj;
16820 : fail:
16821 : {
16822 0 : if (arg2) free(arg2);
16823 : }
16824 : {
16825 : /* See whether we need to update the Python buffer. */
16826 : if (resultobj && wrapper4 && view4.buf)
16827 : {
16828 : int dirty;
16829 : char *new_data = NULL;
16830 : size_t new_size;
16831 :
16832 :
16833 : new_data = wrapper4->data.mem.buffer;
16834 : new_size = wrapper4->data.mem.length;
16835 : dirty = new_data != NULL;
16836 :
16837 :
16838 :
16839 :
16840 :
16841 :
16842 :
16843 : if (dirty)
16844 : {
16845 : /* The buffer is dirty. */
16846 : if (view4.readonly)
16847 : {
16848 : Py_XDECREF(resultobj);
16849 : resultobj = NULL;
16850 : PyErr_SetString(PyExc_ValueError,
16851 : "cannot update read-only buffer");
16852 : }
16853 :
16854 : /* See if we need to truncate the buffer. */
16855 : if (resultobj && view4.len != new_size)
16856 : {
16857 : if (bytesio4 == NULL)
16858 : {
16859 : Py_XDECREF(resultobj);
16860 : resultobj = NULL;
16861 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16862 : }
16863 : else
16864 : {
16865 : PyObject *retval;
16866 : PyBuffer_Release(&view4);
16867 : assert(view4.obj == NULL);
16868 : retval = PyObject_CallMethod(bytesio4, "truncate",
16869 : "l", (long) new_size);
16870 : if (retval == NULL)
16871 : {
16872 : Py_XDECREF(resultobj);
16873 : resultobj = NULL;
16874 : }
16875 : else
16876 : {
16877 : Py_DECREF(retval);
16878 :
16879 : retval = PyObject_CallMethod(bytesio4,
16880 : "getbuffer", NULL);
16881 : if (retval == NULL
16882 : || PyObject_GetBuffer(retval, &view4,
16883 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16884 : {
16885 : Py_XDECREF(resultobj);
16886 : resultobj = NULL;
16887 : }
16888 :
16889 : Py_XDECREF(retval);
16890 :
16891 : if (resultobj && view4.len
16892 : != new_size)
16893 : {
16894 : Py_XDECREF(resultobj);
16895 : resultobj = NULL;
16896 : PyErr_Format(PyExc_ValueError,
16897 : "Expected buffer of length %zu, got %zi",
16898 : new_size,
16899 : view4.len);
16900 : }
16901 : }
16902 : }
16903 : }
16904 : if (resultobj)
16905 : memcpy(view4.buf, new_data, new_size);
16906 : }
16907 :
16908 :
16909 :
16910 : }
16911 :
16912 : /* Free the temporary wrapper, if any. */
16913 0 : if (wrapper4)
16914 0 : gpgme_data_release(wrapper4);
16915 0 : Py_XDECREF (bytesio4);
16916 : if (have_view4 && view4.buf)
16917 : PyBuffer_Release(&view4);
16918 : }
16919 : {
16920 : /* See whether we need to update the Python buffer. */
16921 : if (resultobj && wrapper5 && view5.buf)
16922 : {
16923 : int dirty;
16924 : char *new_data = NULL;
16925 : size_t new_size;
16926 :
16927 :
16928 : new_data = wrapper5->data.mem.buffer;
16929 : new_size = wrapper5->data.mem.length;
16930 : dirty = new_data != NULL;
16931 :
16932 :
16933 :
16934 :
16935 :
16936 :
16937 :
16938 : if (dirty)
16939 : {
16940 : /* The buffer is dirty. */
16941 : if (view5.readonly)
16942 : {
16943 : Py_XDECREF(resultobj);
16944 : resultobj = NULL;
16945 : PyErr_SetString(PyExc_ValueError,
16946 : "cannot update read-only buffer");
16947 : }
16948 :
16949 : /* See if we need to truncate the buffer. */
16950 : if (resultobj && view5.len != new_size)
16951 : {
16952 : if (bytesio5 == NULL)
16953 : {
16954 : Py_XDECREF(resultobj);
16955 : resultobj = NULL;
16956 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
16957 : }
16958 : else
16959 : {
16960 : PyObject *retval;
16961 : PyBuffer_Release(&view5);
16962 : assert(view5.obj == NULL);
16963 : retval = PyObject_CallMethod(bytesio5, "truncate",
16964 : "l", (long) new_size);
16965 : if (retval == NULL)
16966 : {
16967 : Py_XDECREF(resultobj);
16968 : resultobj = NULL;
16969 : }
16970 : else
16971 : {
16972 : Py_DECREF(retval);
16973 :
16974 : retval = PyObject_CallMethod(bytesio5,
16975 : "getbuffer", NULL);
16976 : if (retval == NULL
16977 : || PyObject_GetBuffer(retval, &view5,
16978 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
16979 : {
16980 : Py_XDECREF(resultobj);
16981 : resultobj = NULL;
16982 : }
16983 :
16984 : Py_XDECREF(retval);
16985 :
16986 : if (resultobj && view5.len
16987 : != new_size)
16988 : {
16989 : Py_XDECREF(resultobj);
16990 : resultobj = NULL;
16991 : PyErr_Format(PyExc_ValueError,
16992 : "Expected buffer of length %zu, got %zi",
16993 : new_size,
16994 : view5.len);
16995 : }
16996 : }
16997 : }
16998 : }
16999 : if (resultobj)
17000 : memcpy(view5.buf, new_data, new_size);
17001 : }
17002 :
17003 :
17004 :
17005 : }
17006 :
17007 : /* Free the temporary wrapper, if any. */
17008 0 : if (wrapper5)
17009 0 : gpgme_data_release(wrapper5);
17010 0 : Py_XDECREF (bytesio5);
17011 : if (have_view5 && view5.buf)
17012 : PyBuffer_Release(&view5);
17013 : }
17014 : return NULL;
17015 : }
17016 :
17017 :
17018 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17019 0 : PyObject *resultobj = 0;
17020 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17021 0 : char *arg2 = (char *) 0 ;
17022 0 : void *argp1 = 0 ;
17023 0 : int res1 = 0 ;
17024 : int res2 ;
17025 0 : char *buf2 = 0 ;
17026 0 : int alloc2 = 0 ;
17027 0 : PyObject * obj0 = 0 ;
17028 0 : PyObject * obj1 = 0 ;
17029 :
17030 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_keyid_set",&obj0,&obj1)) SWIG_fail;
17031 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17032 0 : if (!SWIG_IsOK(res1)) {
17033 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17034 : }
17035 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17036 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17037 0 : if (!SWIG_IsOK(res2)) {
17038 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient_keyid_set" "', argument " "2"" of type '" "char *""'");
17039 : }
17040 0 : arg2 = (char *)(buf2);
17041 : {
17042 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17043 0 : if (arg1->keyid) free((char*)arg1->keyid);
17044 0 : if (arg2) {
17045 0 : size_t size = strlen((const char *)(arg2)) + 1;
17046 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
17047 : } else {
17048 0 : arg1->keyid = 0;
17049 : }
17050 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17051 : }
17052 0 : resultobj = SWIG_Py_Void();
17053 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17054 : return resultobj;
17055 : fail:
17056 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17057 : return NULL;
17058 : }
17059 :
17060 :
17061 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17062 8 : PyObject *resultobj = 0;
17063 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17064 8 : void *argp1 = 0 ;
17065 8 : int res1 = 0 ;
17066 8 : PyObject * obj0 = 0 ;
17067 8 : char *result = 0 ;
17068 :
17069 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_keyid_get",&obj0)) SWIG_fail;
17070 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17071 8 : if (!SWIG_IsOK(res1)) {
17072 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17073 : }
17074 8 : arg1 = (struct _gpgme_recipient *)(argp1);
17075 : {
17076 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17077 8 : result = (char *) ((arg1)->keyid);
17078 8 : SWIG_PYTHON_THREAD_END_ALLOW;
17079 : }
17080 8 : resultobj = SWIG_FromCharPtr((const char *)result);
17081 8 : return resultobj;
17082 : fail:
17083 : return NULL;
17084 : }
17085 :
17086 :
17087 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17088 0 : PyObject *resultobj = 0;
17089 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17090 : char *arg2 ;
17091 0 : void *argp1 = 0 ;
17092 0 : int res1 = 0 ;
17093 : char temp2[16+1] ;
17094 : int res2 ;
17095 0 : PyObject * obj0 = 0 ;
17096 0 : PyObject * obj1 = 0 ;
17097 :
17098 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient__keyid_set",&obj0,&obj1)) SWIG_fail;
17099 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17100 0 : if (!SWIG_IsOK(res1)) {
17101 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17102 : }
17103 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17104 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
17105 0 : if (!SWIG_IsOK(res2)) {
17106 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_recipient__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
17107 : }
17108 0 : arg2 = (char *)(temp2);
17109 : {
17110 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17111 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
17112 : else memset(arg1->_keyid,0,16+1*sizeof(char));
17113 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17114 : }
17115 0 : resultobj = SWIG_Py_Void();
17116 0 : return resultobj;
17117 : fail:
17118 : return NULL;
17119 : }
17120 :
17121 :
17122 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17123 0 : PyObject *resultobj = 0;
17124 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17125 0 : void *argp1 = 0 ;
17126 0 : int res1 = 0 ;
17127 0 : PyObject * obj0 = 0 ;
17128 0 : char *result = 0 ;
17129 :
17130 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient__keyid_get",&obj0)) SWIG_fail;
17131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17132 0 : if (!SWIG_IsOK(res1)) {
17133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient__keyid_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17134 : }
17135 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17136 : {
17137 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17138 0 : result = (char *)(char *) ((arg1)->_keyid);
17139 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17140 : }
17141 : {
17142 0 : size_t size = SWIG_strnlen(result, 16+1);
17143 :
17144 :
17145 :
17146 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
17147 : }
17148 0 : return resultobj;
17149 : fail:
17150 : return NULL;
17151 : }
17152 :
17153 :
17154 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17155 0 : PyObject *resultobj = 0;
17156 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17157 : gpgme_pubkey_algo_t arg2 ;
17158 0 : void *argp1 = 0 ;
17159 0 : int res1 = 0 ;
17160 : int val2 ;
17161 0 : int ecode2 = 0 ;
17162 0 : PyObject * obj0 = 0 ;
17163 0 : PyObject * obj1 = 0 ;
17164 :
17165 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
17166 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17167 0 : if (!SWIG_IsOK(res1)) {
17168 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17169 : }
17170 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17171 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17172 0 : if (!SWIG_IsOK(ecode2)) {
17173 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_recipient_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
17174 : }
17175 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
17176 : {
17177 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17178 0 : if (arg1) (arg1)->pubkey_algo = arg2;
17179 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17180 : }
17181 0 : resultobj = SWIG_Py_Void();
17182 0 : return resultobj;
17183 : fail:
17184 : return NULL;
17185 : }
17186 :
17187 :
17188 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17189 8 : PyObject *resultobj = 0;
17190 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17191 8 : void *argp1 = 0 ;
17192 8 : int res1 = 0 ;
17193 8 : PyObject * obj0 = 0 ;
17194 : gpgme_pubkey_algo_t result;
17195 :
17196 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_pubkey_algo_get",&obj0)) SWIG_fail;
17197 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17198 8 : if (!SWIG_IsOK(res1)) {
17199 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17200 : }
17201 8 : arg1 = (struct _gpgme_recipient *)(argp1);
17202 : {
17203 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17204 8 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
17205 8 : SWIG_PYTHON_THREAD_END_ALLOW;
17206 : }
17207 16 : resultobj = SWIG_From_int((int)(result));
17208 8 : return resultobj;
17209 : fail:
17210 : return NULL;
17211 : }
17212 :
17213 :
17214 0 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17215 0 : PyObject *resultobj = 0;
17216 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17217 : gpgme_error_t arg2 ;
17218 0 : void *argp1 = 0 ;
17219 0 : int res1 = 0 ;
17220 0 : PyObject * obj0 = 0 ;
17221 0 : PyObject * obj1 = 0 ;
17222 :
17223 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_recipient_status_set",&obj0,&obj1)) SWIG_fail;
17224 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17225 0 : if (!SWIG_IsOK(res1)) {
17226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_set" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17227 : }
17228 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17229 : {
17230 0 : if (PyLong_Check(obj1))
17231 0 : arg2 = PyLong_AsLong(obj1);
17232 :
17233 0 : else if (PyInt_Check(obj1))
17234 0 : arg2 = PyInt_AsLong(obj1);
17235 :
17236 : else
17237 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
17238 : }
17239 : {
17240 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17241 0 : if (arg1) (arg1)->status = arg2;
17242 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17243 : }
17244 0 : resultobj = SWIG_Py_Void();
17245 0 : return resultobj;
17246 : fail:
17247 : return NULL;
17248 : }
17249 :
17250 :
17251 8 : SWIGINTERN PyObject *_wrap__gpgme_recipient_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17252 8 : PyObject *resultobj = 0;
17253 8 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17254 8 : void *argp1 = 0 ;
17255 8 : int res1 = 0 ;
17256 8 : PyObject * obj0 = 0 ;
17257 : gpgme_error_t result;
17258 :
17259 8 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_recipient_status_get",&obj0)) SWIG_fail;
17260 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, 0 | 0 );
17261 8 : if (!SWIG_IsOK(res1)) {
17262 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_recipient_status_get" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17263 : }
17264 8 : arg1 = (struct _gpgme_recipient *)(argp1);
17265 : {
17266 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17267 8 : result = ((arg1)->status);
17268 8 : SWIG_PYTHON_THREAD_END_ALLOW;
17269 : }
17270 : {
17271 8 : resultobj = PyLong_FromLong(result);
17272 : }
17273 8 : return resultobj;
17274 : fail:
17275 : return NULL;
17276 : }
17277 :
17278 :
17279 0 : SWIGINTERN PyObject *_wrap_new__gpgme_recipient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17280 0 : PyObject *resultobj = 0;
17281 0 : struct _gpgme_recipient *result = 0 ;
17282 :
17283 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_recipient")) SWIG_fail;
17284 : {
17285 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17286 0 : result = (struct _gpgme_recipient *)calloc(1, sizeof(struct _gpgme_recipient));
17287 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17288 : }
17289 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_NEW | 0 );
17290 0 : return resultobj;
17291 : fail:
17292 : return NULL;
17293 : }
17294 :
17295 :
17296 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_recipient(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17297 0 : PyObject *resultobj = 0;
17298 0 : struct _gpgme_recipient *arg1 = (struct _gpgme_recipient *) 0 ;
17299 0 : void *argp1 = 0 ;
17300 0 : int res1 = 0 ;
17301 0 : PyObject * obj0 = 0 ;
17302 :
17303 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_recipient",&obj0)) SWIG_fail;
17304 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
17305 0 : if (!SWIG_IsOK(res1)) {
17306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_recipient" "', argument " "1"" of type '" "struct _gpgme_recipient *""'");
17307 : }
17308 0 : arg1 = (struct _gpgme_recipient *)(argp1);
17309 : {
17310 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17311 0 : free((char *) arg1);
17312 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17313 : }
17314 0 : resultobj = SWIG_Py_Void();
17315 0 : return resultobj;
17316 : fail:
17317 : return NULL;
17318 : }
17319 :
17320 :
17321 27 : SWIGINTERN PyObject *_gpgme_recipient_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17322 : PyObject *obj;
17323 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17324 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_recipient, SWIG_NewClientData(obj));
17325 27 : return SWIG_Py_Void();
17326 : }
17327 :
17328 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17329 0 : PyObject *resultobj = 0;
17330 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17331 0 : char *arg2 = (char *) 0 ;
17332 0 : void *argp1 = 0 ;
17333 0 : int res1 = 0 ;
17334 : int res2 ;
17335 0 : char *buf2 = 0 ;
17336 0 : int alloc2 = 0 ;
17337 0 : PyObject * obj0 = 0 ;
17338 0 : PyObject * obj1 = 0 ;
17339 :
17340 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_unsupported_algorithm_set",&obj0,&obj1)) SWIG_fail;
17341 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17342 0 : if (!SWIG_IsOK(res1)) {
17343 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17344 : }
17345 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17346 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17347 0 : if (!SWIG_IsOK(res2)) {
17348 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_set" "', argument " "2"" of type '" "char *""'");
17349 : }
17350 0 : arg2 = (char *)(buf2);
17351 : {
17352 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17353 0 : if (arg1->unsupported_algorithm) free((char*)arg1->unsupported_algorithm);
17354 0 : if (arg2) {
17355 0 : size_t size = strlen((const char *)(arg2)) + 1;
17356 0 : arg1->unsupported_algorithm = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
17357 : } else {
17358 0 : arg1->unsupported_algorithm = 0;
17359 : }
17360 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17361 : }
17362 0 : resultobj = SWIG_Py_Void();
17363 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17364 : return resultobj;
17365 : fail:
17366 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17367 : return NULL;
17368 : }
17369 :
17370 :
17371 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_unsupported_algorithm_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17372 10 : PyObject *resultobj = 0;
17373 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17374 10 : void *argp1 = 0 ;
17375 10 : int res1 = 0 ;
17376 10 : PyObject * obj0 = 0 ;
17377 10 : char *result = 0 ;
17378 :
17379 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_unsupported_algorithm_get",&obj0)) SWIG_fail;
17380 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17381 10 : if (!SWIG_IsOK(res1)) {
17382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_unsupported_algorithm_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17383 : }
17384 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17385 : {
17386 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17387 10 : result = (char *) ((arg1)->unsupported_algorithm);
17388 10 : SWIG_PYTHON_THREAD_END_ALLOW;
17389 : }
17390 10 : resultobj = SWIG_FromCharPtr((const char *)result);
17391 10 : return resultobj;
17392 : fail:
17393 : return NULL;
17394 : }
17395 :
17396 :
17397 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17398 0 : PyObject *resultobj = 0;
17399 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17400 : unsigned int arg2 ;
17401 0 : void *argp1 = 0 ;
17402 0 : int res1 = 0 ;
17403 : unsigned int val2 ;
17404 0 : int ecode2 = 0 ;
17405 0 : PyObject * obj0 = 0 ;
17406 0 : PyObject * obj1 = 0 ;
17407 :
17408 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_wrong_key_usage_set",&obj0,&obj1)) SWIG_fail;
17409 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17410 0 : if (!SWIG_IsOK(res1)) {
17411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17412 : }
17413 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17414 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
17415 0 : if (!SWIG_IsOK(ecode2)) {
17416 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
17417 : }
17418 0 : arg2 = (unsigned int)(val2);
17419 : {
17420 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17421 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
17422 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17423 : }
17424 0 : resultobj = SWIG_Py_Void();
17425 0 : return resultobj;
17426 : fail:
17427 : return NULL;
17428 : }
17429 :
17430 :
17431 20 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_wrong_key_usage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 20 : PyObject *resultobj = 0;
17433 20 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17434 20 : void *argp1 = 0 ;
17435 20 : int res1 = 0 ;
17436 20 : PyObject * obj0 = 0 ;
17437 : unsigned int result;
17438 :
17439 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_wrong_key_usage_get",&obj0)) SWIG_fail;
17440 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17441 20 : if (!SWIG_IsOK(res1)) {
17442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_wrong_key_usage_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17443 : }
17444 20 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17445 : {
17446 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17447 20 : result = (unsigned int) ((arg1)->wrong_key_usage);
17448 20 : SWIG_PYTHON_THREAD_END_ALLOW;
17449 : }
17450 20 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
17451 20 : return resultobj;
17452 : fail:
17453 : return NULL;
17454 : }
17455 :
17456 :
17457 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17458 0 : PyObject *resultobj = 0;
17459 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17460 : int arg2 ;
17461 0 : void *argp1 = 0 ;
17462 0 : int res1 = 0 ;
17463 : int val2 ;
17464 0 : int ecode2 = 0 ;
17465 0 : PyObject * obj0 = 0 ;
17466 0 : PyObject * obj1 = 0 ;
17467 :
17468 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result__unused_set",&obj0,&obj1)) SWIG_fail;
17469 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17470 0 : if (!SWIG_IsOK(res1)) {
17471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17472 : }
17473 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17474 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
17475 0 : if (!SWIG_IsOK(ecode2)) {
17476 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_decrypt_result__unused_set" "', argument " "2"" of type '" "int""'");
17477 : }
17478 0 : arg2 = (int)(val2);
17479 : {
17480 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17481 0 : if (arg1) (arg1)->_unused = arg2;
17482 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17483 : }
17484 0 : resultobj = SWIG_Py_Void();
17485 0 : return resultobj;
17486 : fail:
17487 : return NULL;
17488 : }
17489 :
17490 :
17491 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17492 0 : PyObject *resultobj = 0;
17493 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17494 0 : void *argp1 = 0 ;
17495 0 : int res1 = 0 ;
17496 0 : PyObject * obj0 = 0 ;
17497 : int result;
17498 :
17499 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result__unused_get",&obj0)) SWIG_fail;
17500 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17501 0 : if (!SWIG_IsOK(res1)) {
17502 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17503 : }
17504 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17505 : {
17506 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17507 0 : result = (int) ((arg1)->_unused);
17508 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17509 : }
17510 0 : resultobj = SWIG_From_int((int)(result));
17511 0 : return resultobj;
17512 : fail:
17513 : return NULL;
17514 : }
17515 :
17516 :
17517 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17518 0 : PyObject *resultobj = 0;
17519 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17520 0 : gpgme_recipient_t arg2 = (gpgme_recipient_t) 0 ;
17521 0 : void *argp1 = 0 ;
17522 0 : int res1 = 0 ;
17523 0 : void *argp2 = 0 ;
17524 0 : int res2 = 0 ;
17525 0 : PyObject * obj0 = 0 ;
17526 0 : PyObject * obj1 = 0 ;
17527 :
17528 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_recipients_set",&obj0,&obj1)) SWIG_fail;
17529 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17530 0 : if (!SWIG_IsOK(res1)) {
17531 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17532 : }
17533 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17534 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_recipient, SWIG_POINTER_DISOWN | 0 );
17535 0 : if (!SWIG_IsOK(res2)) {
17536 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_recipients_set" "', argument " "2"" of type '" "gpgme_recipient_t""'");
17537 : }
17538 0 : arg2 = (gpgme_recipient_t)(argp2);
17539 : {
17540 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17541 0 : if (arg1) (arg1)->recipients = arg2;
17542 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17543 : }
17544 0 : resultobj = SWIG_Py_Void();
17545 0 : return resultobj;
17546 : fail:
17547 : return NULL;
17548 : }
17549 :
17550 :
17551 20 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_recipients_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17552 20 : PyObject *resultobj = 0;
17553 20 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17554 20 : void *argp1 = 0 ;
17555 20 : int res1 = 0 ;
17556 20 : PyObject * obj0 = 0 ;
17557 : gpgme_recipient_t result;
17558 :
17559 20 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_recipients_get",&obj0)) SWIG_fail;
17560 20 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17561 20 : if (!SWIG_IsOK(res1)) {
17562 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_recipients_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17563 : }
17564 20 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17565 : {
17566 20 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17567 20 : result = (gpgme_recipient_t) ((arg1)->recipients);
17568 20 : SWIG_PYTHON_THREAD_END_ALLOW;
17569 : }
17570 : {
17571 : int i;
17572 20 : int size = 0;
17573 : gpgme_recipient_t curr;
17574 36 : for (curr = result; curr != NULL; curr = curr->next) {
17575 16 : size++;
17576 : }
17577 20 : resultobj = PyList_New(size);
17578 36 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
17579 16 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_recipient, 0 );
17580 16 : PyList_SetItem(resultobj, i, o);
17581 : }
17582 : }
17583 : return resultobj;
17584 : fail:
17585 : return NULL;
17586 : }
17587 :
17588 :
17589 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17590 0 : PyObject *resultobj = 0;
17591 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17592 0 : char *arg2 = (char *) 0 ;
17593 0 : void *argp1 = 0 ;
17594 0 : int res1 = 0 ;
17595 : int res2 ;
17596 0 : char *buf2 = 0 ;
17597 0 : int alloc2 = 0 ;
17598 0 : PyObject * obj0 = 0 ;
17599 0 : PyObject * obj1 = 0 ;
17600 :
17601 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_file_name_set",&obj0,&obj1)) SWIG_fail;
17602 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17603 0 : if (!SWIG_IsOK(res1)) {
17604 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_file_name_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17605 : }
17606 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17607 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17608 0 : if (!SWIG_IsOK(res2)) {
17609 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_file_name_set" "', argument " "2"" of type '" "char *""'");
17610 : }
17611 0 : arg2 = (char *)(buf2);
17612 : {
17613 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17614 0 : if (arg1->file_name) free((char*)arg1->file_name);
17615 0 : if (arg2) {
17616 0 : size_t size = strlen((const char *)(arg2)) + 1;
17617 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
17618 : } else {
17619 0 : arg1->file_name = 0;
17620 : }
17621 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17622 : }
17623 0 : resultobj = SWIG_Py_Void();
17624 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17625 : return resultobj;
17626 : fail:
17627 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17628 : return NULL;
17629 : }
17630 :
17631 :
17632 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17633 10 : PyObject *resultobj = 0;
17634 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17635 10 : void *argp1 = 0 ;
17636 10 : int res1 = 0 ;
17637 10 : PyObject * obj0 = 0 ;
17638 10 : char *result = 0 ;
17639 :
17640 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_file_name_get",&obj0)) SWIG_fail;
17641 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17642 10 : if (!SWIG_IsOK(res1)) {
17643 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_file_name_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17644 : }
17645 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17646 : {
17647 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17648 10 : result = (char *) ((arg1)->file_name);
17649 10 : SWIG_PYTHON_THREAD_END_ALLOW;
17650 : }
17651 10 : resultobj = SWIG_FromCharPtr((const char *)result);
17652 10 : return resultobj;
17653 : fail:
17654 : return NULL;
17655 : }
17656 :
17657 :
17658 0 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_session_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17659 0 : PyObject *resultobj = 0;
17660 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17661 0 : char *arg2 = (char *) 0 ;
17662 0 : void *argp1 = 0 ;
17663 0 : int res1 = 0 ;
17664 : int res2 ;
17665 0 : char *buf2 = 0 ;
17666 0 : int alloc2 = 0 ;
17667 0 : PyObject * obj0 = 0 ;
17668 0 : PyObject * obj1 = 0 ;
17669 :
17670 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_decrypt_result_session_key_set",&obj0,&obj1)) SWIG_fail;
17671 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17672 0 : if (!SWIG_IsOK(res1)) {
17673 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_session_key_set" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17674 : }
17675 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17676 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
17677 0 : if (!SWIG_IsOK(res2)) {
17678 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_decrypt_result_session_key_set" "', argument " "2"" of type '" "char *""'");
17679 : }
17680 0 : arg2 = (char *)(buf2);
17681 : {
17682 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17683 0 : if (arg1->session_key) free((char*)arg1->session_key);
17684 0 : if (arg2) {
17685 0 : size_t size = strlen((const char *)(arg2)) + 1;
17686 0 : arg1->session_key = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
17687 : } else {
17688 0 : arg1->session_key = 0;
17689 : }
17690 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17691 : }
17692 0 : resultobj = SWIG_Py_Void();
17693 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17694 : return resultobj;
17695 : fail:
17696 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
17697 : return NULL;
17698 : }
17699 :
17700 :
17701 10 : SWIGINTERN PyObject *_wrap__gpgme_op_decrypt_result_session_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17702 10 : PyObject *resultobj = 0;
17703 10 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17704 10 : void *argp1 = 0 ;
17705 10 : int res1 = 0 ;
17706 10 : PyObject * obj0 = 0 ;
17707 10 : char *result = 0 ;
17708 :
17709 10 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_decrypt_result_session_key_get",&obj0)) SWIG_fail;
17710 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, 0 | 0 );
17711 10 : if (!SWIG_IsOK(res1)) {
17712 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_decrypt_result_session_key_get" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17713 : }
17714 10 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17715 : {
17716 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17717 10 : result = (char *) ((arg1)->session_key);
17718 10 : SWIG_PYTHON_THREAD_END_ALLOW;
17719 : }
17720 10 : resultobj = SWIG_FromCharPtr((const char *)result);
17721 10 : return resultobj;
17722 : fail:
17723 : return NULL;
17724 : }
17725 :
17726 :
17727 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17728 0 : PyObject *resultobj = 0;
17729 0 : struct _gpgme_op_decrypt_result *result = 0 ;
17730 :
17731 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_decrypt_result")) SWIG_fail;
17732 : {
17733 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17734 0 : result = (struct _gpgme_op_decrypt_result *)calloc(1, sizeof(struct _gpgme_op_decrypt_result));
17735 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17736 : }
17737 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_POINTER_NEW | 0 );
17738 0 : return resultobj;
17739 : fail:
17740 : return NULL;
17741 : }
17742 :
17743 :
17744 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17745 0 : PyObject *resultobj = 0;
17746 0 : struct _gpgme_op_decrypt_result *arg1 = (struct _gpgme_op_decrypt_result *) 0 ;
17747 0 : void *argp1 = 0 ;
17748 0 : int res1 = 0 ;
17749 0 : PyObject * obj0 = 0 ;
17750 :
17751 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_decrypt_result",&obj0)) SWIG_fail;
17752 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_POINTER_DISOWN | 0 );
17753 0 : if (!SWIG_IsOK(res1)) {
17754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_decrypt_result" "', argument " "1"" of type '" "struct _gpgme_op_decrypt_result *""'");
17755 : }
17756 0 : arg1 = (struct _gpgme_op_decrypt_result *)(argp1);
17757 : {
17758 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17759 0 : free((char *) arg1);
17760 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17761 : }
17762 0 : resultobj = SWIG_Py_Void();
17763 0 : return resultobj;
17764 : fail:
17765 : return NULL;
17766 : }
17767 :
17768 :
17769 27 : SWIGINTERN PyObject *_gpgme_op_decrypt_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17770 : PyObject *obj;
17771 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
17772 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_decrypt_result, SWIG_NewClientData(obj));
17773 27 : return SWIG_Py_Void();
17774 : }
17775 :
17776 10 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17777 10 : PyObject *resultobj = 0;
17778 10 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
17779 10 : void *argp1 = 0 ;
17780 10 : int res1 = 0 ;
17781 10 : PyObject * obj0 = 0 ;
17782 : gpgme_decrypt_result_t result;
17783 :
17784 10 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_decrypt_result",&obj0)) SWIG_fail;
17785 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
17786 10 : if (!SWIG_IsOK(res1)) {
17787 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
17788 : }
17789 10 : arg1 = (gpgme_ctx_t)(argp1);
17790 : {
17791 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17792 10 : result = (gpgme_decrypt_result_t)gpgme_op_decrypt_result(arg1);
17793 10 : SWIG_PYTHON_THREAD_END_ALLOW;
17794 : }
17795 : {
17796 : PyObject *fragile;
17797 10 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_decrypt_result,
17798 : 0 );
17799 10 : resultobj = _gpg_wrap_result(fragile, "DecryptResult");
17800 10 : Py_DECREF(fragile);
17801 : }
17802 : return resultobj;
17803 : fail:
17804 : return NULL;
17805 : }
17806 :
17807 :
17808 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17809 0 : PyObject *resultobj = 0;
17810 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
17811 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
17812 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
17813 0 : void *argp1 = 0 ;
17814 0 : int res1 = 0 ;
17815 0 : gpgme_data_t wrapper2 = NULL ;
17816 0 : PyObject *bytesio2 = NULL ;
17817 : Py_buffer view2 ;
17818 0 : int have_view2 = 0 ;
17819 0 : gpgme_data_t wrapper3 = NULL ;
17820 0 : PyObject *bytesio3 = NULL ;
17821 : Py_buffer view3 ;
17822 0 : int have_view3 = 0 ;
17823 0 : PyObject * obj0 = 0 ;
17824 0 : PyObject * obj1 = 0 ;
17825 0 : PyObject * obj2 = 0 ;
17826 : gpgme_error_t result;
17827 :
17828 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_start",&obj0,&obj1,&obj2)) SWIG_fail;
17829 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
17830 0 : if (!SWIG_IsOK(res1)) {
17831 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
17832 : }
17833 0 : arg1 = (gpgme_ctx_t)(argp1);
17834 : {
17835 : /* If we create a temporary wrapper2 object, we will store it in
17836 : wrapperN, where N is 2. Here in this fragment, SWIG will
17837 : automatically append 2. */
17838 0 : memset(&view2, 0, sizeof view2);
17839 0 : if (obj1 == Py_None)
17840 0 : arg2 = NULL;
17841 : else {
17842 : PyObject *pypointer;
17843 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
17844 : &bytesio2, &view2);
17845 0 : if (pypointer == NULL)
17846 : return NULL;
17847 0 : have_view2 = !! view2.obj;
17848 :
17849 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
17850 :
17851 : /* Following code is from swig's python.swg. */
17852 :
17853 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
17854 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17855 0 : Py_DECREF(pypointer);
17856 : return NULL;
17857 : }
17858 0 : Py_DECREF(pypointer);
17859 : }
17860 : }
17861 : {
17862 : /* If we create a temporary wrapper3 object, we will store it in
17863 : wrapperN, where N is 3. Here in this fragment, SWIG will
17864 : automatically append 3. */
17865 0 : memset(&view3, 0, sizeof view3);
17866 0 : if (obj2 == Py_None)
17867 0 : arg3 = NULL;
17868 : else {
17869 : PyObject *pypointer;
17870 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
17871 : &bytesio3, &view3);
17872 0 : if (pypointer == NULL)
17873 : return NULL;
17874 0 : have_view3 = !! view3.obj;
17875 :
17876 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
17877 :
17878 : /* Following code is from swig's python.swg. */
17879 :
17880 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
17881 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
17882 0 : Py_DECREF(pypointer);
17883 : return NULL;
17884 : }
17885 0 : Py_DECREF(pypointer);
17886 : }
17887 : }
17888 : {
17889 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
17890 0 : result = gpgme_op_decrypt_start(arg1,arg2,arg3);
17891 0 : SWIG_PYTHON_THREAD_END_ALLOW;
17892 : }
17893 : {
17894 0 : resultobj = PyLong_FromLong(result);
17895 : }
17896 : {
17897 : /* See whether we need to update the Python buffer. */
17898 0 : if (resultobj && wrapper2 && view2.buf)
17899 : {
17900 : int dirty;
17901 0 : char *new_data = NULL;
17902 : size_t new_size;
17903 :
17904 :
17905 0 : new_data = wrapper2->data.mem.buffer;
17906 0 : new_size = wrapper2->data.mem.length;
17907 0 : dirty = new_data != NULL;
17908 :
17909 :
17910 :
17911 :
17912 :
17913 :
17914 :
17915 0 : if (dirty)
17916 : {
17917 : /* The buffer is dirty. */
17918 0 : if (view2.readonly)
17919 : {
17920 0 : Py_XDECREF(resultobj);
17921 0 : resultobj = NULL;
17922 0 : PyErr_SetString(PyExc_ValueError,
17923 : "cannot update read-only buffer");
17924 : }
17925 :
17926 : /* See if we need to truncate the buffer. */
17927 0 : if (resultobj && view2.len != new_size)
17928 : {
17929 0 : if (bytesio2 == NULL)
17930 : {
17931 0 : Py_XDECREF(resultobj);
17932 0 : resultobj = NULL;
17933 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
17934 : }
17935 : else
17936 : {
17937 : PyObject *retval;
17938 0 : PyBuffer_Release(&view2);
17939 : assert(view2.obj == NULL);
17940 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
17941 : "l", (long) new_size);
17942 0 : if (retval == NULL)
17943 : {
17944 0 : Py_XDECREF(resultobj);
17945 : resultobj = NULL;
17946 : }
17947 : else
17948 : {
17949 0 : Py_DECREF(retval);
17950 :
17951 0 : retval = PyObject_CallMethod(bytesio2,
17952 : "getbuffer", NULL);
17953 0 : if (retval == NULL
17954 0 : || PyObject_GetBuffer(retval, &view2,
17955 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
17956 : {
17957 0 : Py_XDECREF(resultobj);
17958 : resultobj = NULL;
17959 : }
17960 :
17961 0 : Py_XDECREF(retval);
17962 :
17963 0 : if (resultobj && view2.len
17964 : != new_size)
17965 : {
17966 0 : Py_XDECREF(resultobj);
17967 0 : resultobj = NULL;
17968 0 : PyErr_Format(PyExc_ValueError,
17969 : "Expected buffer of length %zu, got %zi",
17970 : new_size,
17971 : view2.len);
17972 : }
17973 : }
17974 : }
17975 : }
17976 0 : if (resultobj)
17977 0 : memcpy(view2.buf, new_data, new_size);
17978 : }
17979 :
17980 :
17981 :
17982 : }
17983 :
17984 : /* Free the temporary wrapper, if any. */
17985 0 : if (wrapper2)
17986 0 : gpgme_data_release(wrapper2);
17987 0 : Py_XDECREF (bytesio2);
17988 0 : if (have_view2 && view2.buf)
17989 0 : PyBuffer_Release(&view2);
17990 : }
17991 : {
17992 : /* See whether we need to update the Python buffer. */
17993 0 : if (resultobj && wrapper3 && view3.buf)
17994 : {
17995 : int dirty;
17996 0 : char *new_data = NULL;
17997 : size_t new_size;
17998 :
17999 :
18000 0 : new_data = wrapper3->data.mem.buffer;
18001 0 : new_size = wrapper3->data.mem.length;
18002 0 : dirty = new_data != NULL;
18003 :
18004 :
18005 :
18006 :
18007 :
18008 :
18009 :
18010 0 : if (dirty)
18011 : {
18012 : /* The buffer is dirty. */
18013 0 : if (view3.readonly)
18014 : {
18015 0 : Py_XDECREF(resultobj);
18016 0 : resultobj = NULL;
18017 0 : PyErr_SetString(PyExc_ValueError,
18018 : "cannot update read-only buffer");
18019 : }
18020 :
18021 : /* See if we need to truncate the buffer. */
18022 0 : if (resultobj && view3.len != new_size)
18023 : {
18024 0 : if (bytesio3 == NULL)
18025 : {
18026 0 : Py_XDECREF(resultobj);
18027 0 : resultobj = NULL;
18028 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18029 : }
18030 : else
18031 : {
18032 : PyObject *retval;
18033 0 : PyBuffer_Release(&view3);
18034 : assert(view3.obj == NULL);
18035 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
18036 : "l", (long) new_size);
18037 0 : if (retval == NULL)
18038 : {
18039 0 : Py_XDECREF(resultobj);
18040 : resultobj = NULL;
18041 : }
18042 : else
18043 : {
18044 0 : Py_DECREF(retval);
18045 :
18046 0 : retval = PyObject_CallMethod(bytesio3,
18047 : "getbuffer", NULL);
18048 0 : if (retval == NULL
18049 0 : || PyObject_GetBuffer(retval, &view3,
18050 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18051 : {
18052 0 : Py_XDECREF(resultobj);
18053 : resultobj = NULL;
18054 : }
18055 :
18056 0 : Py_XDECREF(retval);
18057 :
18058 0 : if (resultobj && view3.len
18059 : != new_size)
18060 : {
18061 0 : Py_XDECREF(resultobj);
18062 0 : resultobj = NULL;
18063 0 : PyErr_Format(PyExc_ValueError,
18064 : "Expected buffer of length %zu, got %zi",
18065 : new_size,
18066 : view3.len);
18067 : }
18068 : }
18069 : }
18070 : }
18071 0 : if (resultobj)
18072 0 : memcpy(view3.buf, new_data, new_size);
18073 : }
18074 :
18075 :
18076 :
18077 : }
18078 :
18079 : /* Free the temporary wrapper, if any. */
18080 0 : if (wrapper3)
18081 0 : gpgme_data_release(wrapper3);
18082 0 : Py_XDECREF (bytesio3);
18083 0 : if (have_view3 && view3.buf)
18084 0 : PyBuffer_Release(&view3);
18085 : }
18086 : return resultobj;
18087 : fail:
18088 : {
18089 : /* See whether we need to update the Python buffer. */
18090 : if (resultobj && wrapper2 && view2.buf)
18091 : {
18092 : int dirty;
18093 : char *new_data = NULL;
18094 : size_t new_size;
18095 :
18096 :
18097 : new_data = wrapper2->data.mem.buffer;
18098 : new_size = wrapper2->data.mem.length;
18099 : dirty = new_data != NULL;
18100 :
18101 :
18102 :
18103 :
18104 :
18105 :
18106 :
18107 : if (dirty)
18108 : {
18109 : /* The buffer is dirty. */
18110 : if (view2.readonly)
18111 : {
18112 : Py_XDECREF(resultobj);
18113 : resultobj = NULL;
18114 : PyErr_SetString(PyExc_ValueError,
18115 : "cannot update read-only buffer");
18116 : }
18117 :
18118 : /* See if we need to truncate the buffer. */
18119 : if (resultobj && view2.len != new_size)
18120 : {
18121 : if (bytesio2 == NULL)
18122 : {
18123 : Py_XDECREF(resultobj);
18124 : resultobj = NULL;
18125 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18126 : }
18127 : else
18128 : {
18129 : PyObject *retval;
18130 : PyBuffer_Release(&view2);
18131 : assert(view2.obj == NULL);
18132 : retval = PyObject_CallMethod(bytesio2, "truncate",
18133 : "l", (long) new_size);
18134 : if (retval == NULL)
18135 : {
18136 : Py_XDECREF(resultobj);
18137 : resultobj = NULL;
18138 : }
18139 : else
18140 : {
18141 : Py_DECREF(retval);
18142 :
18143 : retval = PyObject_CallMethod(bytesio2,
18144 : "getbuffer", NULL);
18145 : if (retval == NULL
18146 : || PyObject_GetBuffer(retval, &view2,
18147 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18148 : {
18149 : Py_XDECREF(resultobj);
18150 : resultobj = NULL;
18151 : }
18152 :
18153 : Py_XDECREF(retval);
18154 :
18155 : if (resultobj && view2.len
18156 : != new_size)
18157 : {
18158 : Py_XDECREF(resultobj);
18159 : resultobj = NULL;
18160 : PyErr_Format(PyExc_ValueError,
18161 : "Expected buffer of length %zu, got %zi",
18162 : new_size,
18163 : view2.len);
18164 : }
18165 : }
18166 : }
18167 : }
18168 : if (resultobj)
18169 : memcpy(view2.buf, new_data, new_size);
18170 : }
18171 :
18172 :
18173 :
18174 : }
18175 :
18176 : /* Free the temporary wrapper, if any. */
18177 0 : if (wrapper2)
18178 0 : gpgme_data_release(wrapper2);
18179 0 : Py_XDECREF (bytesio2);
18180 : if (have_view2 && view2.buf)
18181 : PyBuffer_Release(&view2);
18182 : }
18183 : {
18184 : /* See whether we need to update the Python buffer. */
18185 : if (resultobj && wrapper3 && view3.buf)
18186 : {
18187 : int dirty;
18188 : char *new_data = NULL;
18189 : size_t new_size;
18190 :
18191 :
18192 : new_data = wrapper3->data.mem.buffer;
18193 : new_size = wrapper3->data.mem.length;
18194 : dirty = new_data != NULL;
18195 :
18196 :
18197 :
18198 :
18199 :
18200 :
18201 :
18202 : if (dirty)
18203 : {
18204 : /* The buffer is dirty. */
18205 : if (view3.readonly)
18206 : {
18207 : Py_XDECREF(resultobj);
18208 : resultobj = NULL;
18209 : PyErr_SetString(PyExc_ValueError,
18210 : "cannot update read-only buffer");
18211 : }
18212 :
18213 : /* See if we need to truncate the buffer. */
18214 : if (resultobj && view3.len != new_size)
18215 : {
18216 : if (bytesio3 == NULL)
18217 : {
18218 : Py_XDECREF(resultobj);
18219 : resultobj = NULL;
18220 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18221 : }
18222 : else
18223 : {
18224 : PyObject *retval;
18225 : PyBuffer_Release(&view3);
18226 : assert(view3.obj == NULL);
18227 : retval = PyObject_CallMethod(bytesio3, "truncate",
18228 : "l", (long) new_size);
18229 : if (retval == NULL)
18230 : {
18231 : Py_XDECREF(resultobj);
18232 : resultobj = NULL;
18233 : }
18234 : else
18235 : {
18236 : Py_DECREF(retval);
18237 :
18238 : retval = PyObject_CallMethod(bytesio3,
18239 : "getbuffer", NULL);
18240 : if (retval == NULL
18241 : || PyObject_GetBuffer(retval, &view3,
18242 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18243 : {
18244 : Py_XDECREF(resultobj);
18245 : resultobj = NULL;
18246 : }
18247 :
18248 : Py_XDECREF(retval);
18249 :
18250 : if (resultobj && view3.len
18251 : != new_size)
18252 : {
18253 : Py_XDECREF(resultobj);
18254 : resultobj = NULL;
18255 : PyErr_Format(PyExc_ValueError,
18256 : "Expected buffer of length %zu, got %zi",
18257 : new_size,
18258 : view3.len);
18259 : }
18260 : }
18261 : }
18262 : }
18263 : if (resultobj)
18264 : memcpy(view3.buf, new_data, new_size);
18265 : }
18266 :
18267 :
18268 :
18269 : }
18270 :
18271 : /* Free the temporary wrapper, if any. */
18272 0 : if (wrapper3)
18273 0 : gpgme_data_release(wrapper3);
18274 0 : Py_XDECREF (bytesio3);
18275 : if (have_view3 && view3.buf)
18276 : PyBuffer_Release(&view3);
18277 : }
18278 : return NULL;
18279 : }
18280 :
18281 :
18282 4 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 4 : PyObject *resultobj = 0;
18284 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18285 4 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
18286 4 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
18287 4 : void *argp1 = 0 ;
18288 4 : int res1 = 0 ;
18289 4 : gpgme_data_t wrapper2 = NULL ;
18290 4 : PyObject *bytesio2 = NULL ;
18291 : Py_buffer view2 ;
18292 4 : int have_view2 = 0 ;
18293 4 : gpgme_data_t wrapper3 = NULL ;
18294 4 : PyObject *bytesio3 = NULL ;
18295 : Py_buffer view3 ;
18296 4 : int have_view3 = 0 ;
18297 4 : PyObject * obj0 = 0 ;
18298 4 : PyObject * obj1 = 0 ;
18299 4 : PyObject * obj2 = 0 ;
18300 : gpgme_error_t result;
18301 :
18302 4 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt",&obj0,&obj1,&obj2)) SWIG_fail;
18303 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18304 4 : if (!SWIG_IsOK(res1)) {
18305 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18306 : }
18307 4 : arg1 = (gpgme_ctx_t)(argp1);
18308 : {
18309 : /* If we create a temporary wrapper2 object, we will store it in
18310 : wrapperN, where N is 2. Here in this fragment, SWIG will
18311 : automatically append 2. */
18312 4 : memset(&view2, 0, sizeof view2);
18313 4 : if (obj1 == Py_None)
18314 0 : arg2 = NULL;
18315 : else {
18316 : PyObject *pypointer;
18317 4 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
18318 : &bytesio2, &view2);
18319 4 : if (pypointer == NULL)
18320 : return NULL;
18321 4 : have_view2 = !! view2.obj;
18322 :
18323 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
18324 :
18325 : /* Following code is from swig's python.swg. */
18326 :
18327 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
18328 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18329 0 : Py_DECREF(pypointer);
18330 : return NULL;
18331 : }
18332 4 : Py_DECREF(pypointer);
18333 : }
18334 : }
18335 : {
18336 : /* If we create a temporary wrapper3 object, we will store it in
18337 : wrapperN, where N is 3. Here in this fragment, SWIG will
18338 : automatically append 3. */
18339 4 : memset(&view3, 0, sizeof view3);
18340 4 : if (obj2 == Py_None)
18341 0 : arg3 = NULL;
18342 : else {
18343 : PyObject *pypointer;
18344 4 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
18345 : &bytesio3, &view3);
18346 4 : if (pypointer == NULL)
18347 : return NULL;
18348 4 : have_view3 = !! view3.obj;
18349 :
18350 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
18351 :
18352 : /* Following code is from swig's python.swg. */
18353 :
18354 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
18355 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18356 0 : Py_DECREF(pypointer);
18357 : return NULL;
18358 : }
18359 4 : Py_DECREF(pypointer);
18360 : }
18361 : }
18362 : {
18363 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18364 4 : result = gpgme_op_decrypt(arg1,arg2,arg3);
18365 4 : SWIG_PYTHON_THREAD_END_ALLOW;
18366 : }
18367 : {
18368 4 : resultobj = PyLong_FromLong(result);
18369 : }
18370 : {
18371 : /* See whether we need to update the Python buffer. */
18372 4 : if (resultobj && wrapper2 && view2.buf)
18373 : {
18374 : int dirty;
18375 0 : char *new_data = NULL;
18376 : size_t new_size;
18377 :
18378 :
18379 0 : new_data = wrapper2->data.mem.buffer;
18380 0 : new_size = wrapper2->data.mem.length;
18381 0 : dirty = new_data != NULL;
18382 :
18383 :
18384 :
18385 :
18386 :
18387 :
18388 :
18389 0 : if (dirty)
18390 : {
18391 : /* The buffer is dirty. */
18392 0 : if (view2.readonly)
18393 : {
18394 0 : Py_XDECREF(resultobj);
18395 0 : resultobj = NULL;
18396 0 : PyErr_SetString(PyExc_ValueError,
18397 : "cannot update read-only buffer");
18398 : }
18399 :
18400 : /* See if we need to truncate the buffer. */
18401 0 : if (resultobj && view2.len != new_size)
18402 : {
18403 0 : if (bytesio2 == NULL)
18404 : {
18405 0 : Py_XDECREF(resultobj);
18406 0 : resultobj = NULL;
18407 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18408 : }
18409 : else
18410 : {
18411 : PyObject *retval;
18412 0 : PyBuffer_Release(&view2);
18413 : assert(view2.obj == NULL);
18414 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
18415 : "l", (long) new_size);
18416 0 : if (retval == NULL)
18417 : {
18418 0 : Py_XDECREF(resultobj);
18419 : resultobj = NULL;
18420 : }
18421 : else
18422 : {
18423 0 : Py_DECREF(retval);
18424 :
18425 0 : retval = PyObject_CallMethod(bytesio2,
18426 : "getbuffer", NULL);
18427 0 : if (retval == NULL
18428 0 : || PyObject_GetBuffer(retval, &view2,
18429 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18430 : {
18431 0 : Py_XDECREF(resultobj);
18432 : resultobj = NULL;
18433 : }
18434 :
18435 0 : Py_XDECREF(retval);
18436 :
18437 0 : if (resultobj && view2.len
18438 : != new_size)
18439 : {
18440 0 : Py_XDECREF(resultobj);
18441 0 : resultobj = NULL;
18442 0 : PyErr_Format(PyExc_ValueError,
18443 : "Expected buffer of length %zu, got %zi",
18444 : new_size,
18445 : view2.len);
18446 : }
18447 : }
18448 : }
18449 : }
18450 0 : if (resultobj)
18451 0 : memcpy(view2.buf, new_data, new_size);
18452 : }
18453 :
18454 :
18455 :
18456 : }
18457 :
18458 : /* Free the temporary wrapper, if any. */
18459 4 : if (wrapper2)
18460 0 : gpgme_data_release(wrapper2);
18461 4 : Py_XDECREF (bytesio2);
18462 4 : if (have_view2 && view2.buf)
18463 0 : PyBuffer_Release(&view2);
18464 : }
18465 : {
18466 : /* See whether we need to update the Python buffer. */
18467 4 : if (resultobj && wrapper3 && view3.buf)
18468 : {
18469 : int dirty;
18470 0 : char *new_data = NULL;
18471 : size_t new_size;
18472 :
18473 :
18474 0 : new_data = wrapper3->data.mem.buffer;
18475 0 : new_size = wrapper3->data.mem.length;
18476 0 : dirty = new_data != NULL;
18477 :
18478 :
18479 :
18480 :
18481 :
18482 :
18483 :
18484 0 : if (dirty)
18485 : {
18486 : /* The buffer is dirty. */
18487 0 : if (view3.readonly)
18488 : {
18489 0 : Py_XDECREF(resultobj);
18490 0 : resultobj = NULL;
18491 0 : PyErr_SetString(PyExc_ValueError,
18492 : "cannot update read-only buffer");
18493 : }
18494 :
18495 : /* See if we need to truncate the buffer. */
18496 0 : if (resultobj && view3.len != new_size)
18497 : {
18498 0 : if (bytesio3 == NULL)
18499 : {
18500 0 : Py_XDECREF(resultobj);
18501 0 : resultobj = NULL;
18502 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18503 : }
18504 : else
18505 : {
18506 : PyObject *retval;
18507 0 : PyBuffer_Release(&view3);
18508 : assert(view3.obj == NULL);
18509 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
18510 : "l", (long) new_size);
18511 0 : if (retval == NULL)
18512 : {
18513 0 : Py_XDECREF(resultobj);
18514 : resultobj = NULL;
18515 : }
18516 : else
18517 : {
18518 0 : Py_DECREF(retval);
18519 :
18520 0 : retval = PyObject_CallMethod(bytesio3,
18521 : "getbuffer", NULL);
18522 0 : if (retval == NULL
18523 0 : || PyObject_GetBuffer(retval, &view3,
18524 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18525 : {
18526 0 : Py_XDECREF(resultobj);
18527 : resultobj = NULL;
18528 : }
18529 :
18530 0 : Py_XDECREF(retval);
18531 :
18532 0 : if (resultobj && view3.len
18533 : != new_size)
18534 : {
18535 0 : Py_XDECREF(resultobj);
18536 0 : resultobj = NULL;
18537 0 : PyErr_Format(PyExc_ValueError,
18538 : "Expected buffer of length %zu, got %zi",
18539 : new_size,
18540 : view3.len);
18541 : }
18542 : }
18543 : }
18544 : }
18545 0 : if (resultobj)
18546 0 : memcpy(view3.buf, new_data, new_size);
18547 : }
18548 :
18549 :
18550 :
18551 : }
18552 :
18553 : /* Free the temporary wrapper, if any. */
18554 4 : if (wrapper3)
18555 0 : gpgme_data_release(wrapper3);
18556 4 : Py_XDECREF (bytesio3);
18557 4 : if (have_view3 && view3.buf)
18558 0 : PyBuffer_Release(&view3);
18559 : }
18560 : return resultobj;
18561 : fail:
18562 : {
18563 : /* See whether we need to update the Python buffer. */
18564 : if (resultobj && wrapper2 && view2.buf)
18565 : {
18566 : int dirty;
18567 : char *new_data = NULL;
18568 : size_t new_size;
18569 :
18570 :
18571 : new_data = wrapper2->data.mem.buffer;
18572 : new_size = wrapper2->data.mem.length;
18573 : dirty = new_data != NULL;
18574 :
18575 :
18576 :
18577 :
18578 :
18579 :
18580 :
18581 : if (dirty)
18582 : {
18583 : /* The buffer is dirty. */
18584 : if (view2.readonly)
18585 : {
18586 : Py_XDECREF(resultobj);
18587 : resultobj = NULL;
18588 : PyErr_SetString(PyExc_ValueError,
18589 : "cannot update read-only buffer");
18590 : }
18591 :
18592 : /* See if we need to truncate the buffer. */
18593 : if (resultobj && view2.len != new_size)
18594 : {
18595 : if (bytesio2 == NULL)
18596 : {
18597 : Py_XDECREF(resultobj);
18598 : resultobj = NULL;
18599 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18600 : }
18601 : else
18602 : {
18603 : PyObject *retval;
18604 : PyBuffer_Release(&view2);
18605 : assert(view2.obj == NULL);
18606 : retval = PyObject_CallMethod(bytesio2, "truncate",
18607 : "l", (long) new_size);
18608 : if (retval == NULL)
18609 : {
18610 : Py_XDECREF(resultobj);
18611 : resultobj = NULL;
18612 : }
18613 : else
18614 : {
18615 : Py_DECREF(retval);
18616 :
18617 : retval = PyObject_CallMethod(bytesio2,
18618 : "getbuffer", NULL);
18619 : if (retval == NULL
18620 : || PyObject_GetBuffer(retval, &view2,
18621 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18622 : {
18623 : Py_XDECREF(resultobj);
18624 : resultobj = NULL;
18625 : }
18626 :
18627 : Py_XDECREF(retval);
18628 :
18629 : if (resultobj && view2.len
18630 : != new_size)
18631 : {
18632 : Py_XDECREF(resultobj);
18633 : resultobj = NULL;
18634 : PyErr_Format(PyExc_ValueError,
18635 : "Expected buffer of length %zu, got %zi",
18636 : new_size,
18637 : view2.len);
18638 : }
18639 : }
18640 : }
18641 : }
18642 : if (resultobj)
18643 : memcpy(view2.buf, new_data, new_size);
18644 : }
18645 :
18646 :
18647 :
18648 : }
18649 :
18650 : /* Free the temporary wrapper, if any. */
18651 0 : if (wrapper2)
18652 0 : gpgme_data_release(wrapper2);
18653 0 : Py_XDECREF (bytesio2);
18654 : if (have_view2 && view2.buf)
18655 : PyBuffer_Release(&view2);
18656 : }
18657 : {
18658 : /* See whether we need to update the Python buffer. */
18659 : if (resultobj && wrapper3 && view3.buf)
18660 : {
18661 : int dirty;
18662 : char *new_data = NULL;
18663 : size_t new_size;
18664 :
18665 :
18666 : new_data = wrapper3->data.mem.buffer;
18667 : new_size = wrapper3->data.mem.length;
18668 : dirty = new_data != NULL;
18669 :
18670 :
18671 :
18672 :
18673 :
18674 :
18675 :
18676 : if (dirty)
18677 : {
18678 : /* The buffer is dirty. */
18679 : if (view3.readonly)
18680 : {
18681 : Py_XDECREF(resultobj);
18682 : resultobj = NULL;
18683 : PyErr_SetString(PyExc_ValueError,
18684 : "cannot update read-only buffer");
18685 : }
18686 :
18687 : /* See if we need to truncate the buffer. */
18688 : if (resultobj && view3.len != new_size)
18689 : {
18690 : if (bytesio3 == NULL)
18691 : {
18692 : Py_XDECREF(resultobj);
18693 : resultobj = NULL;
18694 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18695 : }
18696 : else
18697 : {
18698 : PyObject *retval;
18699 : PyBuffer_Release(&view3);
18700 : assert(view3.obj == NULL);
18701 : retval = PyObject_CallMethod(bytesio3, "truncate",
18702 : "l", (long) new_size);
18703 : if (retval == NULL)
18704 : {
18705 : Py_XDECREF(resultobj);
18706 : resultobj = NULL;
18707 : }
18708 : else
18709 : {
18710 : Py_DECREF(retval);
18711 :
18712 : retval = PyObject_CallMethod(bytesio3,
18713 : "getbuffer", NULL);
18714 : if (retval == NULL
18715 : || PyObject_GetBuffer(retval, &view3,
18716 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18717 : {
18718 : Py_XDECREF(resultobj);
18719 : resultobj = NULL;
18720 : }
18721 :
18722 : Py_XDECREF(retval);
18723 :
18724 : if (resultobj && view3.len
18725 : != new_size)
18726 : {
18727 : Py_XDECREF(resultobj);
18728 : resultobj = NULL;
18729 : PyErr_Format(PyExc_ValueError,
18730 : "Expected buffer of length %zu, got %zi",
18731 : new_size,
18732 : view3.len);
18733 : }
18734 : }
18735 : }
18736 : }
18737 : if (resultobj)
18738 : memcpy(view3.buf, new_data, new_size);
18739 : }
18740 :
18741 :
18742 :
18743 : }
18744 :
18745 : /* Free the temporary wrapper, if any. */
18746 0 : if (wrapper3)
18747 0 : gpgme_data_release(wrapper3);
18748 0 : Py_XDECREF (bytesio3);
18749 : if (have_view3 && view3.buf)
18750 : PyBuffer_Release(&view3);
18751 : }
18752 : return NULL;
18753 : }
18754 :
18755 :
18756 0 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18757 0 : PyObject *resultobj = 0;
18758 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
18759 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
18760 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
18761 0 : void *argp1 = 0 ;
18762 0 : int res1 = 0 ;
18763 0 : gpgme_data_t wrapper2 = NULL ;
18764 0 : PyObject *bytesio2 = NULL ;
18765 : Py_buffer view2 ;
18766 0 : int have_view2 = 0 ;
18767 0 : gpgme_data_t wrapper3 = NULL ;
18768 0 : PyObject *bytesio3 = NULL ;
18769 : Py_buffer view3 ;
18770 0 : int have_view3 = 0 ;
18771 0 : PyObject * obj0 = 0 ;
18772 0 : PyObject * obj1 = 0 ;
18773 0 : PyObject * obj2 = 0 ;
18774 : gpgme_error_t result;
18775 :
18776 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify_start",&obj0,&obj1,&obj2)) SWIG_fail;
18777 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
18778 0 : if (!SWIG_IsOK(res1)) {
18779 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
18780 : }
18781 0 : arg1 = (gpgme_ctx_t)(argp1);
18782 : {
18783 : /* If we create a temporary wrapper2 object, we will store it in
18784 : wrapperN, where N is 2. Here in this fragment, SWIG will
18785 : automatically append 2. */
18786 0 : memset(&view2, 0, sizeof view2);
18787 0 : if (obj1 == Py_None)
18788 0 : arg2 = NULL;
18789 : else {
18790 : PyObject *pypointer;
18791 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
18792 : &bytesio2, &view2);
18793 0 : if (pypointer == NULL)
18794 : return NULL;
18795 0 : have_view2 = !! view2.obj;
18796 :
18797 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
18798 :
18799 : /* Following code is from swig's python.swg. */
18800 :
18801 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
18802 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18803 0 : Py_DECREF(pypointer);
18804 : return NULL;
18805 : }
18806 0 : Py_DECREF(pypointer);
18807 : }
18808 : }
18809 : {
18810 : /* If we create a temporary wrapper3 object, we will store it in
18811 : wrapperN, where N is 3. Here in this fragment, SWIG will
18812 : automatically append 3. */
18813 0 : memset(&view3, 0, sizeof view3);
18814 0 : if (obj2 == Py_None)
18815 0 : arg3 = NULL;
18816 : else {
18817 : PyObject *pypointer;
18818 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
18819 : &bytesio3, &view3);
18820 0 : if (pypointer == NULL)
18821 : return NULL;
18822 0 : have_view3 = !! view3.obj;
18823 :
18824 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
18825 :
18826 : /* Following code is from swig's python.swg. */
18827 :
18828 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
18829 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
18830 0 : Py_DECREF(pypointer);
18831 : return NULL;
18832 : }
18833 0 : Py_DECREF(pypointer);
18834 : }
18835 : }
18836 : {
18837 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
18838 0 : result = gpgme_op_decrypt_verify_start(arg1,arg2,arg3);
18839 0 : SWIG_PYTHON_THREAD_END_ALLOW;
18840 : }
18841 : {
18842 0 : resultobj = PyLong_FromLong(result);
18843 : }
18844 : {
18845 : /* See whether we need to update the Python buffer. */
18846 0 : if (resultobj && wrapper2 && view2.buf)
18847 : {
18848 : int dirty;
18849 0 : char *new_data = NULL;
18850 : size_t new_size;
18851 :
18852 :
18853 0 : new_data = wrapper2->data.mem.buffer;
18854 0 : new_size = wrapper2->data.mem.length;
18855 0 : dirty = new_data != NULL;
18856 :
18857 :
18858 :
18859 :
18860 :
18861 :
18862 :
18863 0 : if (dirty)
18864 : {
18865 : /* The buffer is dirty. */
18866 0 : if (view2.readonly)
18867 : {
18868 0 : Py_XDECREF(resultobj);
18869 0 : resultobj = NULL;
18870 0 : PyErr_SetString(PyExc_ValueError,
18871 : "cannot update read-only buffer");
18872 : }
18873 :
18874 : /* See if we need to truncate the buffer. */
18875 0 : if (resultobj && view2.len != new_size)
18876 : {
18877 0 : if (bytesio2 == NULL)
18878 : {
18879 0 : Py_XDECREF(resultobj);
18880 0 : resultobj = NULL;
18881 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18882 : }
18883 : else
18884 : {
18885 : PyObject *retval;
18886 0 : PyBuffer_Release(&view2);
18887 : assert(view2.obj == NULL);
18888 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
18889 : "l", (long) new_size);
18890 0 : if (retval == NULL)
18891 : {
18892 0 : Py_XDECREF(resultobj);
18893 : resultobj = NULL;
18894 : }
18895 : else
18896 : {
18897 0 : Py_DECREF(retval);
18898 :
18899 0 : retval = PyObject_CallMethod(bytesio2,
18900 : "getbuffer", NULL);
18901 0 : if (retval == NULL
18902 0 : || PyObject_GetBuffer(retval, &view2,
18903 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18904 : {
18905 0 : Py_XDECREF(resultobj);
18906 : resultobj = NULL;
18907 : }
18908 :
18909 0 : Py_XDECREF(retval);
18910 :
18911 0 : if (resultobj && view2.len
18912 : != new_size)
18913 : {
18914 0 : Py_XDECREF(resultobj);
18915 0 : resultobj = NULL;
18916 0 : PyErr_Format(PyExc_ValueError,
18917 : "Expected buffer of length %zu, got %zi",
18918 : new_size,
18919 : view2.len);
18920 : }
18921 : }
18922 : }
18923 : }
18924 0 : if (resultobj)
18925 0 : memcpy(view2.buf, new_data, new_size);
18926 : }
18927 :
18928 :
18929 :
18930 : }
18931 :
18932 : /* Free the temporary wrapper, if any. */
18933 0 : if (wrapper2)
18934 0 : gpgme_data_release(wrapper2);
18935 0 : Py_XDECREF (bytesio2);
18936 0 : if (have_view2 && view2.buf)
18937 0 : PyBuffer_Release(&view2);
18938 : }
18939 : {
18940 : /* See whether we need to update the Python buffer. */
18941 0 : if (resultobj && wrapper3 && view3.buf)
18942 : {
18943 : int dirty;
18944 0 : char *new_data = NULL;
18945 : size_t new_size;
18946 :
18947 :
18948 0 : new_data = wrapper3->data.mem.buffer;
18949 0 : new_size = wrapper3->data.mem.length;
18950 0 : dirty = new_data != NULL;
18951 :
18952 :
18953 :
18954 :
18955 :
18956 :
18957 :
18958 0 : if (dirty)
18959 : {
18960 : /* The buffer is dirty. */
18961 0 : if (view3.readonly)
18962 : {
18963 0 : Py_XDECREF(resultobj);
18964 0 : resultobj = NULL;
18965 0 : PyErr_SetString(PyExc_ValueError,
18966 : "cannot update read-only buffer");
18967 : }
18968 :
18969 : /* See if we need to truncate the buffer. */
18970 0 : if (resultobj && view3.len != new_size)
18971 : {
18972 0 : if (bytesio3 == NULL)
18973 : {
18974 0 : Py_XDECREF(resultobj);
18975 0 : resultobj = NULL;
18976 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
18977 : }
18978 : else
18979 : {
18980 : PyObject *retval;
18981 0 : PyBuffer_Release(&view3);
18982 : assert(view3.obj == NULL);
18983 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
18984 : "l", (long) new_size);
18985 0 : if (retval == NULL)
18986 : {
18987 0 : Py_XDECREF(resultobj);
18988 : resultobj = NULL;
18989 : }
18990 : else
18991 : {
18992 0 : Py_DECREF(retval);
18993 :
18994 0 : retval = PyObject_CallMethod(bytesio3,
18995 : "getbuffer", NULL);
18996 0 : if (retval == NULL
18997 0 : || PyObject_GetBuffer(retval, &view3,
18998 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
18999 : {
19000 0 : Py_XDECREF(resultobj);
19001 : resultobj = NULL;
19002 : }
19003 :
19004 0 : Py_XDECREF(retval);
19005 :
19006 0 : if (resultobj && view3.len
19007 : != new_size)
19008 : {
19009 0 : Py_XDECREF(resultobj);
19010 0 : resultobj = NULL;
19011 0 : PyErr_Format(PyExc_ValueError,
19012 : "Expected buffer of length %zu, got %zi",
19013 : new_size,
19014 : view3.len);
19015 : }
19016 : }
19017 : }
19018 : }
19019 0 : if (resultobj)
19020 0 : memcpy(view3.buf, new_data, new_size);
19021 : }
19022 :
19023 :
19024 :
19025 : }
19026 :
19027 : /* Free the temporary wrapper, if any. */
19028 0 : if (wrapper3)
19029 0 : gpgme_data_release(wrapper3);
19030 0 : Py_XDECREF (bytesio3);
19031 0 : if (have_view3 && view3.buf)
19032 0 : PyBuffer_Release(&view3);
19033 : }
19034 : return resultobj;
19035 : fail:
19036 : {
19037 : /* See whether we need to update the Python buffer. */
19038 : if (resultobj && wrapper2 && view2.buf)
19039 : {
19040 : int dirty;
19041 : char *new_data = NULL;
19042 : size_t new_size;
19043 :
19044 :
19045 : new_data = wrapper2->data.mem.buffer;
19046 : new_size = wrapper2->data.mem.length;
19047 : dirty = new_data != NULL;
19048 :
19049 :
19050 :
19051 :
19052 :
19053 :
19054 :
19055 : if (dirty)
19056 : {
19057 : /* The buffer is dirty. */
19058 : if (view2.readonly)
19059 : {
19060 : Py_XDECREF(resultobj);
19061 : resultobj = NULL;
19062 : PyErr_SetString(PyExc_ValueError,
19063 : "cannot update read-only buffer");
19064 : }
19065 :
19066 : /* See if we need to truncate the buffer. */
19067 : if (resultobj && view2.len != new_size)
19068 : {
19069 : if (bytesio2 == NULL)
19070 : {
19071 : Py_XDECREF(resultobj);
19072 : resultobj = NULL;
19073 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19074 : }
19075 : else
19076 : {
19077 : PyObject *retval;
19078 : PyBuffer_Release(&view2);
19079 : assert(view2.obj == NULL);
19080 : retval = PyObject_CallMethod(bytesio2, "truncate",
19081 : "l", (long) new_size);
19082 : if (retval == NULL)
19083 : {
19084 : Py_XDECREF(resultobj);
19085 : resultobj = NULL;
19086 : }
19087 : else
19088 : {
19089 : Py_DECREF(retval);
19090 :
19091 : retval = PyObject_CallMethod(bytesio2,
19092 : "getbuffer", NULL);
19093 : if (retval == NULL
19094 : || PyObject_GetBuffer(retval, &view2,
19095 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19096 : {
19097 : Py_XDECREF(resultobj);
19098 : resultobj = NULL;
19099 : }
19100 :
19101 : Py_XDECREF(retval);
19102 :
19103 : if (resultobj && view2.len
19104 : != new_size)
19105 : {
19106 : Py_XDECREF(resultobj);
19107 : resultobj = NULL;
19108 : PyErr_Format(PyExc_ValueError,
19109 : "Expected buffer of length %zu, got %zi",
19110 : new_size,
19111 : view2.len);
19112 : }
19113 : }
19114 : }
19115 : }
19116 : if (resultobj)
19117 : memcpy(view2.buf, new_data, new_size);
19118 : }
19119 :
19120 :
19121 :
19122 : }
19123 :
19124 : /* Free the temporary wrapper, if any. */
19125 0 : if (wrapper2)
19126 0 : gpgme_data_release(wrapper2);
19127 0 : Py_XDECREF (bytesio2);
19128 : if (have_view2 && view2.buf)
19129 : PyBuffer_Release(&view2);
19130 : }
19131 : {
19132 : /* See whether we need to update the Python buffer. */
19133 : if (resultobj && wrapper3 && view3.buf)
19134 : {
19135 : int dirty;
19136 : char *new_data = NULL;
19137 : size_t new_size;
19138 :
19139 :
19140 : new_data = wrapper3->data.mem.buffer;
19141 : new_size = wrapper3->data.mem.length;
19142 : dirty = new_data != NULL;
19143 :
19144 :
19145 :
19146 :
19147 :
19148 :
19149 :
19150 : if (dirty)
19151 : {
19152 : /* The buffer is dirty. */
19153 : if (view3.readonly)
19154 : {
19155 : Py_XDECREF(resultobj);
19156 : resultobj = NULL;
19157 : PyErr_SetString(PyExc_ValueError,
19158 : "cannot update read-only buffer");
19159 : }
19160 :
19161 : /* See if we need to truncate the buffer. */
19162 : if (resultobj && view3.len != new_size)
19163 : {
19164 : if (bytesio3 == NULL)
19165 : {
19166 : Py_XDECREF(resultobj);
19167 : resultobj = NULL;
19168 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19169 : }
19170 : else
19171 : {
19172 : PyObject *retval;
19173 : PyBuffer_Release(&view3);
19174 : assert(view3.obj == NULL);
19175 : retval = PyObject_CallMethod(bytesio3, "truncate",
19176 : "l", (long) new_size);
19177 : if (retval == NULL)
19178 : {
19179 : Py_XDECREF(resultobj);
19180 : resultobj = NULL;
19181 : }
19182 : else
19183 : {
19184 : Py_DECREF(retval);
19185 :
19186 : retval = PyObject_CallMethod(bytesio3,
19187 : "getbuffer", NULL);
19188 : if (retval == NULL
19189 : || PyObject_GetBuffer(retval, &view3,
19190 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19191 : {
19192 : Py_XDECREF(resultobj);
19193 : resultobj = NULL;
19194 : }
19195 :
19196 : Py_XDECREF(retval);
19197 :
19198 : if (resultobj && view3.len
19199 : != new_size)
19200 : {
19201 : Py_XDECREF(resultobj);
19202 : resultobj = NULL;
19203 : PyErr_Format(PyExc_ValueError,
19204 : "Expected buffer of length %zu, got %zi",
19205 : new_size,
19206 : view3.len);
19207 : }
19208 : }
19209 : }
19210 : }
19211 : if (resultobj)
19212 : memcpy(view3.buf, new_data, new_size);
19213 : }
19214 :
19215 :
19216 :
19217 : }
19218 :
19219 : /* Free the temporary wrapper, if any. */
19220 0 : if (wrapper3)
19221 0 : gpgme_data_release(wrapper3);
19222 0 : Py_XDECREF (bytesio3);
19223 : if (have_view3 && view3.buf)
19224 : PyBuffer_Release(&view3);
19225 : }
19226 : return NULL;
19227 : }
19228 :
19229 :
19230 8 : SWIGINTERN PyObject *_wrap_gpgme_op_decrypt_verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19231 8 : PyObject *resultobj = 0;
19232 8 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
19233 8 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
19234 8 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
19235 8 : void *argp1 = 0 ;
19236 8 : int res1 = 0 ;
19237 8 : gpgme_data_t wrapper2 = NULL ;
19238 8 : PyObject *bytesio2 = NULL ;
19239 : Py_buffer view2 ;
19240 8 : int have_view2 = 0 ;
19241 8 : gpgme_data_t wrapper3 = NULL ;
19242 8 : PyObject *bytesio3 = NULL ;
19243 : Py_buffer view3 ;
19244 8 : int have_view3 = 0 ;
19245 8 : PyObject * obj0 = 0 ;
19246 8 : PyObject * obj1 = 0 ;
19247 8 : PyObject * obj2 = 0 ;
19248 : gpgme_error_t result;
19249 :
19250 8 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_decrypt_verify",&obj0,&obj1,&obj2)) SWIG_fail;
19251 8 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
19252 8 : if (!SWIG_IsOK(res1)) {
19253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_decrypt_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
19254 : }
19255 8 : arg1 = (gpgme_ctx_t)(argp1);
19256 : {
19257 : /* If we create a temporary wrapper2 object, we will store it in
19258 : wrapperN, where N is 2. Here in this fragment, SWIG will
19259 : automatically append 2. */
19260 8 : memset(&view2, 0, sizeof view2);
19261 8 : if (obj1 == Py_None)
19262 0 : arg2 = NULL;
19263 : else {
19264 : PyObject *pypointer;
19265 8 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
19266 : &bytesio2, &view2);
19267 8 : if (pypointer == NULL)
19268 : return NULL;
19269 8 : have_view2 = !! view2.obj;
19270 :
19271 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
19272 :
19273 : /* Following code is from swig's python.swg. */
19274 :
19275 8 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
19276 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
19277 0 : Py_DECREF(pypointer);
19278 : return NULL;
19279 : }
19280 8 : Py_DECREF(pypointer);
19281 : }
19282 : }
19283 : {
19284 : /* If we create a temporary wrapper3 object, we will store it in
19285 : wrapperN, where N is 3. Here in this fragment, SWIG will
19286 : automatically append 3. */
19287 8 : memset(&view3, 0, sizeof view3);
19288 8 : if (obj2 == Py_None)
19289 0 : arg3 = NULL;
19290 : else {
19291 : PyObject *pypointer;
19292 8 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
19293 : &bytesio3, &view3);
19294 8 : if (pypointer == NULL)
19295 : return NULL;
19296 8 : have_view3 = !! view3.obj;
19297 :
19298 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
19299 :
19300 : /* Following code is from swig's python.swg. */
19301 :
19302 8 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
19303 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
19304 0 : Py_DECREF(pypointer);
19305 : return NULL;
19306 : }
19307 8 : Py_DECREF(pypointer);
19308 : }
19309 : }
19310 : {
19311 8 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19312 8 : result = gpgme_op_decrypt_verify(arg1,arg2,arg3);
19313 8 : SWIG_PYTHON_THREAD_END_ALLOW;
19314 : }
19315 : {
19316 8 : resultobj = PyLong_FromLong(result);
19317 : }
19318 : {
19319 : /* See whether we need to update the Python buffer. */
19320 8 : if (resultobj && wrapper2 && view2.buf)
19321 : {
19322 : int dirty;
19323 4 : char *new_data = NULL;
19324 : size_t new_size;
19325 :
19326 :
19327 4 : new_data = wrapper2->data.mem.buffer;
19328 4 : new_size = wrapper2->data.mem.length;
19329 4 : dirty = new_data != NULL;
19330 :
19331 :
19332 :
19333 :
19334 :
19335 :
19336 :
19337 4 : if (dirty)
19338 : {
19339 : /* The buffer is dirty. */
19340 0 : if (view2.readonly)
19341 : {
19342 0 : Py_XDECREF(resultobj);
19343 0 : resultobj = NULL;
19344 0 : PyErr_SetString(PyExc_ValueError,
19345 : "cannot update read-only buffer");
19346 : }
19347 :
19348 : /* See if we need to truncate the buffer. */
19349 0 : if (resultobj && view2.len != new_size)
19350 : {
19351 0 : if (bytesio2 == NULL)
19352 : {
19353 0 : Py_XDECREF(resultobj);
19354 0 : resultobj = NULL;
19355 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19356 : }
19357 : else
19358 : {
19359 : PyObject *retval;
19360 0 : PyBuffer_Release(&view2);
19361 : assert(view2.obj == NULL);
19362 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
19363 : "l", (long) new_size);
19364 0 : if (retval == NULL)
19365 : {
19366 0 : Py_XDECREF(resultobj);
19367 : resultobj = NULL;
19368 : }
19369 : else
19370 : {
19371 0 : Py_DECREF(retval);
19372 :
19373 0 : retval = PyObject_CallMethod(bytesio2,
19374 : "getbuffer", NULL);
19375 0 : if (retval == NULL
19376 0 : || PyObject_GetBuffer(retval, &view2,
19377 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19378 : {
19379 0 : Py_XDECREF(resultobj);
19380 : resultobj = NULL;
19381 : }
19382 :
19383 0 : Py_XDECREF(retval);
19384 :
19385 0 : if (resultobj && view2.len
19386 : != new_size)
19387 : {
19388 0 : Py_XDECREF(resultobj);
19389 0 : resultobj = NULL;
19390 0 : PyErr_Format(PyExc_ValueError,
19391 : "Expected buffer of length %zu, got %zi",
19392 : new_size,
19393 : view2.len);
19394 : }
19395 : }
19396 : }
19397 : }
19398 0 : if (resultobj)
19399 0 : memcpy(view2.buf, new_data, new_size);
19400 : }
19401 :
19402 :
19403 :
19404 : }
19405 :
19406 : /* Free the temporary wrapper, if any. */
19407 8 : if (wrapper2)
19408 7 : gpgme_data_release(wrapper2);
19409 8 : Py_XDECREF (bytesio2);
19410 8 : if (have_view2 && view2.buf)
19411 4 : PyBuffer_Release(&view2);
19412 : }
19413 : {
19414 : /* See whether we need to update the Python buffer. */
19415 8 : if (resultobj && wrapper3 && view3.buf)
19416 : {
19417 : int dirty;
19418 0 : char *new_data = NULL;
19419 : size_t new_size;
19420 :
19421 :
19422 0 : new_data = wrapper3->data.mem.buffer;
19423 0 : new_size = wrapper3->data.mem.length;
19424 0 : dirty = new_data != NULL;
19425 :
19426 :
19427 :
19428 :
19429 :
19430 :
19431 :
19432 0 : if (dirty)
19433 : {
19434 : /* The buffer is dirty. */
19435 0 : if (view3.readonly)
19436 : {
19437 0 : Py_XDECREF(resultobj);
19438 0 : resultobj = NULL;
19439 0 : PyErr_SetString(PyExc_ValueError,
19440 : "cannot update read-only buffer");
19441 : }
19442 :
19443 : /* See if we need to truncate the buffer. */
19444 0 : if (resultobj && view3.len != new_size)
19445 : {
19446 0 : if (bytesio3 == NULL)
19447 : {
19448 0 : Py_XDECREF(resultobj);
19449 0 : resultobj = NULL;
19450 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19451 : }
19452 : else
19453 : {
19454 : PyObject *retval;
19455 0 : PyBuffer_Release(&view3);
19456 : assert(view3.obj == NULL);
19457 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
19458 : "l", (long) new_size);
19459 0 : if (retval == NULL)
19460 : {
19461 0 : Py_XDECREF(resultobj);
19462 : resultobj = NULL;
19463 : }
19464 : else
19465 : {
19466 0 : Py_DECREF(retval);
19467 :
19468 0 : retval = PyObject_CallMethod(bytesio3,
19469 : "getbuffer", NULL);
19470 0 : if (retval == NULL
19471 0 : || PyObject_GetBuffer(retval, &view3,
19472 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19473 : {
19474 0 : Py_XDECREF(resultobj);
19475 : resultobj = NULL;
19476 : }
19477 :
19478 0 : Py_XDECREF(retval);
19479 :
19480 0 : if (resultobj && view3.len
19481 : != new_size)
19482 : {
19483 0 : Py_XDECREF(resultobj);
19484 0 : resultobj = NULL;
19485 0 : PyErr_Format(PyExc_ValueError,
19486 : "Expected buffer of length %zu, got %zi",
19487 : new_size,
19488 : view3.len);
19489 : }
19490 : }
19491 : }
19492 : }
19493 0 : if (resultobj)
19494 0 : memcpy(view3.buf, new_data, new_size);
19495 : }
19496 :
19497 :
19498 :
19499 : }
19500 :
19501 : /* Free the temporary wrapper, if any. */
19502 8 : if (wrapper3)
19503 0 : gpgme_data_release(wrapper3);
19504 8 : Py_XDECREF (bytesio3);
19505 8 : if (have_view3 && view3.buf)
19506 0 : PyBuffer_Release(&view3);
19507 : }
19508 : return resultobj;
19509 : fail:
19510 : {
19511 : /* See whether we need to update the Python buffer. */
19512 : if (resultobj && wrapper2 && view2.buf)
19513 : {
19514 : int dirty;
19515 : char *new_data = NULL;
19516 : size_t new_size;
19517 :
19518 :
19519 : new_data = wrapper2->data.mem.buffer;
19520 : new_size = wrapper2->data.mem.length;
19521 : dirty = new_data != NULL;
19522 :
19523 :
19524 :
19525 :
19526 :
19527 :
19528 :
19529 : if (dirty)
19530 : {
19531 : /* The buffer is dirty. */
19532 : if (view2.readonly)
19533 : {
19534 : Py_XDECREF(resultobj);
19535 : resultobj = NULL;
19536 : PyErr_SetString(PyExc_ValueError,
19537 : "cannot update read-only buffer");
19538 : }
19539 :
19540 : /* See if we need to truncate the buffer. */
19541 : if (resultobj && view2.len != new_size)
19542 : {
19543 : if (bytesio2 == NULL)
19544 : {
19545 : Py_XDECREF(resultobj);
19546 : resultobj = NULL;
19547 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19548 : }
19549 : else
19550 : {
19551 : PyObject *retval;
19552 : PyBuffer_Release(&view2);
19553 : assert(view2.obj == NULL);
19554 : retval = PyObject_CallMethod(bytesio2, "truncate",
19555 : "l", (long) new_size);
19556 : if (retval == NULL)
19557 : {
19558 : Py_XDECREF(resultobj);
19559 : resultobj = NULL;
19560 : }
19561 : else
19562 : {
19563 : Py_DECREF(retval);
19564 :
19565 : retval = PyObject_CallMethod(bytesio2,
19566 : "getbuffer", NULL);
19567 : if (retval == NULL
19568 : || PyObject_GetBuffer(retval, &view2,
19569 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19570 : {
19571 : Py_XDECREF(resultobj);
19572 : resultobj = NULL;
19573 : }
19574 :
19575 : Py_XDECREF(retval);
19576 :
19577 : if (resultobj && view2.len
19578 : != new_size)
19579 : {
19580 : Py_XDECREF(resultobj);
19581 : resultobj = NULL;
19582 : PyErr_Format(PyExc_ValueError,
19583 : "Expected buffer of length %zu, got %zi",
19584 : new_size,
19585 : view2.len);
19586 : }
19587 : }
19588 : }
19589 : }
19590 : if (resultobj)
19591 : memcpy(view2.buf, new_data, new_size);
19592 : }
19593 :
19594 :
19595 :
19596 : }
19597 :
19598 : /* Free the temporary wrapper, if any. */
19599 0 : if (wrapper2)
19600 0 : gpgme_data_release(wrapper2);
19601 0 : Py_XDECREF (bytesio2);
19602 : if (have_view2 && view2.buf)
19603 : PyBuffer_Release(&view2);
19604 : }
19605 : {
19606 : /* See whether we need to update the Python buffer. */
19607 : if (resultobj && wrapper3 && view3.buf)
19608 : {
19609 : int dirty;
19610 : char *new_data = NULL;
19611 : size_t new_size;
19612 :
19613 :
19614 : new_data = wrapper3->data.mem.buffer;
19615 : new_size = wrapper3->data.mem.length;
19616 : dirty = new_data != NULL;
19617 :
19618 :
19619 :
19620 :
19621 :
19622 :
19623 :
19624 : if (dirty)
19625 : {
19626 : /* The buffer is dirty. */
19627 : if (view3.readonly)
19628 : {
19629 : Py_XDECREF(resultobj);
19630 : resultobj = NULL;
19631 : PyErr_SetString(PyExc_ValueError,
19632 : "cannot update read-only buffer");
19633 : }
19634 :
19635 : /* See if we need to truncate the buffer. */
19636 : if (resultobj && view3.len != new_size)
19637 : {
19638 : if (bytesio3 == NULL)
19639 : {
19640 : Py_XDECREF(resultobj);
19641 : resultobj = NULL;
19642 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
19643 : }
19644 : else
19645 : {
19646 : PyObject *retval;
19647 : PyBuffer_Release(&view3);
19648 : assert(view3.obj == NULL);
19649 : retval = PyObject_CallMethod(bytesio3, "truncate",
19650 : "l", (long) new_size);
19651 : if (retval == NULL)
19652 : {
19653 : Py_XDECREF(resultobj);
19654 : resultobj = NULL;
19655 : }
19656 : else
19657 : {
19658 : Py_DECREF(retval);
19659 :
19660 : retval = PyObject_CallMethod(bytesio3,
19661 : "getbuffer", NULL);
19662 : if (retval == NULL
19663 : || PyObject_GetBuffer(retval, &view3,
19664 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
19665 : {
19666 : Py_XDECREF(resultobj);
19667 : resultobj = NULL;
19668 : }
19669 :
19670 : Py_XDECREF(retval);
19671 :
19672 : if (resultobj && view3.len
19673 : != new_size)
19674 : {
19675 : Py_XDECREF(resultobj);
19676 : resultobj = NULL;
19677 : PyErr_Format(PyExc_ValueError,
19678 : "Expected buffer of length %zu, got %zi",
19679 : new_size,
19680 : view3.len);
19681 : }
19682 : }
19683 : }
19684 : }
19685 : if (resultobj)
19686 : memcpy(view3.buf, new_data, new_size);
19687 : }
19688 :
19689 :
19690 :
19691 : }
19692 :
19693 : /* Free the temporary wrapper, if any. */
19694 0 : if (wrapper3)
19695 0 : gpgme_data_release(wrapper3);
19696 0 : Py_XDECREF (bytesio3);
19697 : if (have_view3 && view3.buf)
19698 : PyBuffer_Release(&view3);
19699 : }
19700 : return NULL;
19701 : }
19702 :
19703 :
19704 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19705 0 : PyObject *resultobj = 0;
19706 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19707 : gpgme_sig_mode_t arg2 ;
19708 0 : void *argp1 = 0 ;
19709 0 : int res1 = 0 ;
19710 : int val2 ;
19711 0 : int ecode2 = 0 ;
19712 0 : PyObject * obj0 = 0 ;
19713 0 : PyObject * obj1 = 0 ;
19714 :
19715 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_type_set",&obj0,&obj1)) SWIG_fail;
19716 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19717 0 : if (!SWIG_IsOK(res1)) {
19718 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19719 : }
19720 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19721 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19722 0 : if (!SWIG_IsOK(ecode2)) {
19723 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_type_set" "', argument " "2"" of type '" "gpgme_sig_mode_t""'");
19724 : }
19725 0 : arg2 = (gpgme_sig_mode_t)(val2);
19726 : {
19727 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19728 0 : if (arg1) (arg1)->type = arg2;
19729 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19730 : }
19731 0 : resultobj = SWIG_Py_Void();
19732 0 : return resultobj;
19733 : fail:
19734 : return NULL;
19735 : }
19736 :
19737 :
19738 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19739 25 : PyObject *resultobj = 0;
19740 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19741 25 : void *argp1 = 0 ;
19742 25 : int res1 = 0 ;
19743 25 : PyObject * obj0 = 0 ;
19744 : gpgme_sig_mode_t result;
19745 :
19746 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_type_get",&obj0)) SWIG_fail;
19747 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19748 25 : if (!SWIG_IsOK(res1)) {
19749 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_type_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19750 : }
19751 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
19752 : {
19753 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19754 25 : result = (gpgme_sig_mode_t) ((arg1)->type);
19755 25 : SWIG_PYTHON_THREAD_END_ALLOW;
19756 : }
19757 50 : resultobj = SWIG_From_int((int)(result));
19758 25 : return resultobj;
19759 : fail:
19760 : return NULL;
19761 : }
19762 :
19763 :
19764 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19765 0 : PyObject *resultobj = 0;
19766 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19767 : gpgme_pubkey_algo_t arg2 ;
19768 0 : void *argp1 = 0 ;
19769 0 : int res1 = 0 ;
19770 : int val2 ;
19771 0 : int ecode2 = 0 ;
19772 0 : PyObject * obj0 = 0 ;
19773 0 : PyObject * obj1 = 0 ;
19774 :
19775 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
19776 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19777 0 : if (!SWIG_IsOK(res1)) {
19778 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19779 : }
19780 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19781 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19782 0 : if (!SWIG_IsOK(ecode2)) {
19783 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
19784 : }
19785 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
19786 : {
19787 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19788 0 : if (arg1) (arg1)->pubkey_algo = arg2;
19789 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19790 : }
19791 0 : resultobj = SWIG_Py_Void();
19792 0 : return resultobj;
19793 : fail:
19794 : return NULL;
19795 : }
19796 :
19797 :
19798 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19799 25 : PyObject *resultobj = 0;
19800 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19801 25 : void *argp1 = 0 ;
19802 25 : int res1 = 0 ;
19803 25 : PyObject * obj0 = 0 ;
19804 : gpgme_pubkey_algo_t result;
19805 :
19806 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_pubkey_algo_get",&obj0)) SWIG_fail;
19807 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19808 25 : if (!SWIG_IsOK(res1)) {
19809 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19810 : }
19811 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
19812 : {
19813 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19814 25 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
19815 25 : SWIG_PYTHON_THREAD_END_ALLOW;
19816 : }
19817 50 : resultobj = SWIG_From_int((int)(result));
19818 25 : return resultobj;
19819 : fail:
19820 : return NULL;
19821 : }
19822 :
19823 :
19824 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19825 0 : PyObject *resultobj = 0;
19826 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19827 : gpgme_hash_algo_t arg2 ;
19828 0 : void *argp1 = 0 ;
19829 0 : int res1 = 0 ;
19830 : int val2 ;
19831 0 : int ecode2 = 0 ;
19832 0 : PyObject * obj0 = 0 ;
19833 0 : PyObject * obj1 = 0 ;
19834 :
19835 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_hash_algo_set",&obj0,&obj1)) SWIG_fail;
19836 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19837 0 : if (!SWIG_IsOK(res1)) {
19838 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19839 : }
19840 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19841 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
19842 0 : if (!SWIG_IsOK(ecode2)) {
19843 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
19844 : }
19845 0 : arg2 = (gpgme_hash_algo_t)(val2);
19846 : {
19847 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19848 0 : if (arg1) (arg1)->hash_algo = arg2;
19849 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19850 : }
19851 0 : resultobj = SWIG_Py_Void();
19852 0 : return resultobj;
19853 : fail:
19854 : return NULL;
19855 : }
19856 :
19857 :
19858 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_hash_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19859 25 : PyObject *resultobj = 0;
19860 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19861 25 : void *argp1 = 0 ;
19862 25 : int res1 = 0 ;
19863 25 : PyObject * obj0 = 0 ;
19864 : gpgme_hash_algo_t result;
19865 :
19866 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_hash_algo_get",&obj0)) SWIG_fail;
19867 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19868 25 : if (!SWIG_IsOK(res1)) {
19869 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19870 : }
19871 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
19872 : {
19873 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19874 25 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
19875 25 : SWIG_PYTHON_THREAD_END_ALLOW;
19876 : }
19877 50 : resultobj = SWIG_From_int((int)(result));
19878 25 : return resultobj;
19879 : fail:
19880 : return NULL;
19881 : }
19882 :
19883 :
19884 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19885 0 : PyObject *resultobj = 0;
19886 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19887 : unsigned long arg2 ;
19888 0 : void *argp1 = 0 ;
19889 0 : int res1 = 0 ;
19890 : unsigned long val2 ;
19891 0 : int ecode2 = 0 ;
19892 0 : PyObject * obj0 = 0 ;
19893 0 : PyObject * obj1 = 0 ;
19894 :
19895 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature__obsolete_class_set",&obj0,&obj1)) SWIG_fail;
19896 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19897 0 : if (!SWIG_IsOK(res1)) {
19898 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19899 : }
19900 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19901 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19902 0 : if (!SWIG_IsOK(ecode2)) {
19903 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature__obsolete_class_set" "', argument " "2"" of type '" "unsigned long""'");
19904 : }
19905 0 : arg2 = (unsigned long)(val2);
19906 : {
19907 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19908 0 : if (arg1) (arg1)->_obsolete_class = arg2;
19909 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19910 : }
19911 0 : resultobj = SWIG_Py_Void();
19912 0 : return resultobj;
19913 : fail:
19914 : return NULL;
19915 : }
19916 :
19917 :
19918 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature__obsolete_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19919 0 : PyObject *resultobj = 0;
19920 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19921 0 : void *argp1 = 0 ;
19922 0 : int res1 = 0 ;
19923 0 : PyObject * obj0 = 0 ;
19924 : unsigned long result;
19925 :
19926 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature__obsolete_class_get",&obj0)) SWIG_fail;
19927 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19928 0 : if (!SWIG_IsOK(res1)) {
19929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature__obsolete_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19930 : }
19931 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19932 : {
19933 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19934 0 : result = (unsigned long) ((arg1)->_obsolete_class);
19935 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19936 : }
19937 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
19938 0 : return resultobj;
19939 : fail:
19940 : return NULL;
19941 : }
19942 :
19943 :
19944 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19945 0 : PyObject *resultobj = 0;
19946 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19947 : long arg2 ;
19948 0 : void *argp1 = 0 ;
19949 0 : int res1 = 0 ;
19950 : long val2 ;
19951 0 : int ecode2 = 0 ;
19952 0 : PyObject * obj0 = 0 ;
19953 0 : PyObject * obj1 = 0 ;
19954 :
19955 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_timestamp_set",&obj0,&obj1)) SWIG_fail;
19956 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19957 0 : if (!SWIG_IsOK(res1)) {
19958 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19959 : }
19960 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
19961 0 : ecode2 = SWIG_AsVal_long(obj1, &val2);
19962 0 : if (!SWIG_IsOK(ecode2)) {
19963 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_timestamp_set" "', argument " "2"" of type '" "long""'");
19964 : }
19965 0 : arg2 = (long)(val2);
19966 : {
19967 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19968 0 : if (arg1) (arg1)->timestamp = arg2;
19969 0 : SWIG_PYTHON_THREAD_END_ALLOW;
19970 : }
19971 0 : resultobj = SWIG_Py_Void();
19972 0 : return resultobj;
19973 : fail:
19974 : return NULL;
19975 : }
19976 :
19977 :
19978 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19979 25 : PyObject *resultobj = 0;
19980 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
19981 25 : void *argp1 = 0 ;
19982 25 : int res1 = 0 ;
19983 25 : PyObject * obj0 = 0 ;
19984 : long result;
19985 :
19986 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_timestamp_get",&obj0)) SWIG_fail;
19987 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
19988 25 : if (!SWIG_IsOK(res1)) {
19989 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
19990 : }
19991 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
19992 : {
19993 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
19994 25 : result = (long) ((arg1)->timestamp);
19995 25 : SWIG_PYTHON_THREAD_END_ALLOW;
19996 : }
19997 25 : resultobj = SWIG_From_long((long)(result));
19998 25 : return resultobj;
19999 : fail:
20000 : return NULL;
20001 : }
20002 :
20003 :
20004 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20005 0 : PyObject *resultobj = 0;
20006 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
20007 0 : char *arg2 = (char *) 0 ;
20008 0 : void *argp1 = 0 ;
20009 0 : int res1 = 0 ;
20010 : int res2 ;
20011 0 : char *buf2 = 0 ;
20012 0 : int alloc2 = 0 ;
20013 0 : PyObject * obj0 = 0 ;
20014 0 : PyObject * obj1 = 0 ;
20015 :
20016 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_fpr_set",&obj0,&obj1)) SWIG_fail;
20017 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
20018 0 : if (!SWIG_IsOK(res1)) {
20019 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
20020 : }
20021 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
20022 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
20023 0 : if (!SWIG_IsOK(res2)) {
20024 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_new_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
20025 : }
20026 0 : arg2 = (char *)(buf2);
20027 : {
20028 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20029 0 : if (arg1->fpr) free((char*)arg1->fpr);
20030 0 : if (arg2) {
20031 0 : size_t size = strlen((const char *)(arg2)) + 1;
20032 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
20033 : } else {
20034 0 : arg1->fpr = 0;
20035 : }
20036 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20037 : }
20038 0 : resultobj = SWIG_Py_Void();
20039 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20040 : return resultobj;
20041 : fail:
20042 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
20043 : return NULL;
20044 : }
20045 :
20046 :
20047 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20048 25 : PyObject *resultobj = 0;
20049 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
20050 25 : void *argp1 = 0 ;
20051 25 : int res1 = 0 ;
20052 25 : PyObject * obj0 = 0 ;
20053 25 : char *result = 0 ;
20054 :
20055 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_fpr_get",&obj0)) SWIG_fail;
20056 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
20057 25 : if (!SWIG_IsOK(res1)) {
20058 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
20059 : }
20060 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
20061 : {
20062 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20063 25 : result = (char *) ((arg1)->fpr);
20064 25 : SWIG_PYTHON_THREAD_END_ALLOW;
20065 : }
20066 25 : resultobj = SWIG_FromCharPtr((const char *)result);
20067 25 : return resultobj;
20068 : fail:
20069 : return NULL;
20070 : }
20071 :
20072 :
20073 0 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20074 0 : PyObject *resultobj = 0;
20075 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
20076 : unsigned int arg2 ;
20077 0 : void *argp1 = 0 ;
20078 0 : int res1 = 0 ;
20079 : unsigned int val2 ;
20080 0 : int ecode2 = 0 ;
20081 0 : PyObject * obj0 = 0 ;
20082 0 : PyObject * obj1 = 0 ;
20083 :
20084 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_new_signature_sig_class_set",&obj0,&obj1)) SWIG_fail;
20085 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
20086 0 : if (!SWIG_IsOK(res1)) {
20087 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
20088 : }
20089 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
20090 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
20091 0 : if (!SWIG_IsOK(ecode2)) {
20092 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_new_signature_sig_class_set" "', argument " "2"" of type '" "unsigned int""'");
20093 : }
20094 0 : arg2 = (unsigned int)(val2);
20095 : {
20096 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20097 0 : if (arg1) (arg1)->sig_class = arg2;
20098 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20099 : }
20100 0 : resultobj = SWIG_Py_Void();
20101 0 : return resultobj;
20102 : fail:
20103 : return NULL;
20104 : }
20105 :
20106 :
20107 25 : SWIGINTERN PyObject *_wrap__gpgme_new_signature_sig_class_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20108 25 : PyObject *resultobj = 0;
20109 25 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
20110 25 : void *argp1 = 0 ;
20111 25 : int res1 = 0 ;
20112 25 : PyObject * obj0 = 0 ;
20113 : unsigned int result;
20114 :
20115 25 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_new_signature_sig_class_get",&obj0)) SWIG_fail;
20116 25 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, 0 | 0 );
20117 25 : if (!SWIG_IsOK(res1)) {
20118 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_new_signature_sig_class_get" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
20119 : }
20120 25 : arg1 = (struct _gpgme_new_signature *)(argp1);
20121 : {
20122 25 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20123 25 : result = (unsigned int) ((arg1)->sig_class);
20124 25 : SWIG_PYTHON_THREAD_END_ALLOW;
20125 : }
20126 25 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
20127 25 : return resultobj;
20128 : fail:
20129 : return NULL;
20130 : }
20131 :
20132 :
20133 0 : SWIGINTERN PyObject *_wrap_new__gpgme_new_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20134 0 : PyObject *resultobj = 0;
20135 0 : struct _gpgme_new_signature *result = 0 ;
20136 :
20137 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_new_signature")) SWIG_fail;
20138 : {
20139 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20140 0 : result = (struct _gpgme_new_signature *)calloc(1, sizeof(struct _gpgme_new_signature));
20141 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20142 : }
20143 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_NEW | 0 );
20144 0 : return resultobj;
20145 : fail:
20146 : return NULL;
20147 : }
20148 :
20149 :
20150 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_new_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20151 0 : PyObject *resultobj = 0;
20152 0 : struct _gpgme_new_signature *arg1 = (struct _gpgme_new_signature *) 0 ;
20153 0 : void *argp1 = 0 ;
20154 0 : int res1 = 0 ;
20155 0 : PyObject * obj0 = 0 ;
20156 :
20157 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_new_signature",&obj0)) SWIG_fail;
20158 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
20159 0 : if (!SWIG_IsOK(res1)) {
20160 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_new_signature" "', argument " "1"" of type '" "struct _gpgme_new_signature *""'");
20161 : }
20162 0 : arg1 = (struct _gpgme_new_signature *)(argp1);
20163 : {
20164 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20165 0 : free((char *) arg1);
20166 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20167 : }
20168 0 : resultobj = SWIG_Py_Void();
20169 0 : return resultobj;
20170 : fail:
20171 : return NULL;
20172 : }
20173 :
20174 :
20175 27 : SWIGINTERN PyObject *_gpgme_new_signature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20176 : PyObject *obj;
20177 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20178 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_new_signature, SWIG_NewClientData(obj));
20179 27 : return SWIG_Py_Void();
20180 : }
20181 :
20182 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 0 : PyObject *resultobj = 0;
20184 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
20185 0 : gpgme_invalid_key_t arg2 = (gpgme_invalid_key_t) 0 ;
20186 0 : void *argp1 = 0 ;
20187 0 : int res1 = 0 ;
20188 0 : void *argp2 = 0 ;
20189 0 : int res2 = 0 ;
20190 0 : PyObject * obj0 = 0 ;
20191 0 : PyObject * obj1 = 0 ;
20192 :
20193 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_sign_result_invalid_signers_set",&obj0,&obj1)) SWIG_fail;
20194 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
20195 0 : if (!SWIG_IsOK(res1)) {
20196 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_invalid_signers_set" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
20197 : }
20198 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
20199 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_invalid_key, SWIG_POINTER_DISOWN | 0 );
20200 0 : if (!SWIG_IsOK(res2)) {
20201 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_invalid_signers_set" "', argument " "2"" of type '" "gpgme_invalid_key_t""'");
20202 : }
20203 0 : arg2 = (gpgme_invalid_key_t)(argp2);
20204 : {
20205 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20206 0 : if (arg1) (arg1)->invalid_signers = arg2;
20207 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20208 : }
20209 0 : resultobj = SWIG_Py_Void();
20210 0 : return resultobj;
20211 : fail:
20212 : return NULL;
20213 : }
20214 :
20215 :
20216 42 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_invalid_signers_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 42 : PyObject *resultobj = 0;
20218 42 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
20219 42 : void *argp1 = 0 ;
20220 42 : int res1 = 0 ;
20221 42 : PyObject * obj0 = 0 ;
20222 : gpgme_invalid_key_t result;
20223 :
20224 42 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_invalid_signers_get",&obj0)) SWIG_fail;
20225 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
20226 42 : if (!SWIG_IsOK(res1)) {
20227 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_invalid_signers_get" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
20228 : }
20229 42 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
20230 : {
20231 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20232 42 : result = (gpgme_invalid_key_t) ((arg1)->invalid_signers);
20233 42 : SWIG_PYTHON_THREAD_END_ALLOW;
20234 : }
20235 : {
20236 : int i;
20237 42 : int size = 0;
20238 : gpgme_invalid_key_t curr;
20239 46 : for (curr = result; curr != NULL; curr = curr->next) {
20240 4 : size++;
20241 : }
20242 42 : resultobj = PyList_New(size);
20243 46 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
20244 4 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_invalid_key, 0 );
20245 4 : PyList_SetItem(resultobj, i, o);
20246 : }
20247 : }
20248 : return resultobj;
20249 : fail:
20250 : return NULL;
20251 : }
20252 :
20253 :
20254 0 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20255 0 : PyObject *resultobj = 0;
20256 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
20257 0 : gpgme_new_signature_t arg2 = (gpgme_new_signature_t) 0 ;
20258 0 : void *argp1 = 0 ;
20259 0 : int res1 = 0 ;
20260 0 : void *argp2 = 0 ;
20261 0 : int res2 = 0 ;
20262 0 : PyObject * obj0 = 0 ;
20263 0 : PyObject * obj1 = 0 ;
20264 :
20265 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_sign_result_signatures_set",&obj0,&obj1)) SWIG_fail;
20266 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
20267 0 : if (!SWIG_IsOK(res1)) {
20268 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
20269 : }
20270 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
20271 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_new_signature, SWIG_POINTER_DISOWN | 0 );
20272 0 : if (!SWIG_IsOK(res2)) {
20273 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_sign_result_signatures_set" "', argument " "2"" of type '" "gpgme_new_signature_t""'");
20274 : }
20275 0 : arg2 = (gpgme_new_signature_t)(argp2);
20276 : {
20277 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20278 0 : if (arg1) (arg1)->signatures = arg2;
20279 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20280 : }
20281 0 : resultobj = SWIG_Py_Void();
20282 0 : return resultobj;
20283 : fail:
20284 : return NULL;
20285 : }
20286 :
20287 :
20288 42 : SWIGINTERN PyObject *_wrap__gpgme_op_sign_result_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20289 42 : PyObject *resultobj = 0;
20290 42 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
20291 42 : void *argp1 = 0 ;
20292 42 : int res1 = 0 ;
20293 42 : PyObject * obj0 = 0 ;
20294 : gpgme_new_signature_t result;
20295 :
20296 42 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_sign_result_signatures_get",&obj0)) SWIG_fail;
20297 42 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, 0 | 0 );
20298 42 : if (!SWIG_IsOK(res1)) {
20299 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_sign_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
20300 : }
20301 42 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
20302 : {
20303 42 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20304 42 : result = (gpgme_new_signature_t) ((arg1)->signatures);
20305 42 : SWIG_PYTHON_THREAD_END_ALLOW;
20306 : }
20307 : {
20308 : int i;
20309 42 : int size = 0;
20310 : gpgme_new_signature_t curr;
20311 92 : for (curr = result; curr != NULL; curr = curr->next) {
20312 50 : size++;
20313 : }
20314 42 : resultobj = PyList_New(size);
20315 92 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
20316 50 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_new_signature, 0 );
20317 50 : PyList_SetItem(resultobj, i, o);
20318 : }
20319 : }
20320 : return resultobj;
20321 : fail:
20322 : return NULL;
20323 : }
20324 :
20325 :
20326 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20327 0 : PyObject *resultobj = 0;
20328 0 : struct _gpgme_op_sign_result *result = 0 ;
20329 :
20330 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_sign_result")) SWIG_fail;
20331 : {
20332 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20333 0 : result = (struct _gpgme_op_sign_result *)calloc(1, sizeof(struct _gpgme_op_sign_result));
20334 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20335 : }
20336 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result, SWIG_POINTER_NEW | 0 );
20337 0 : return resultobj;
20338 : fail:
20339 : return NULL;
20340 : }
20341 :
20342 :
20343 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 0 : PyObject *resultobj = 0;
20345 0 : struct _gpgme_op_sign_result *arg1 = (struct _gpgme_op_sign_result *) 0 ;
20346 0 : void *argp1 = 0 ;
20347 0 : int res1 = 0 ;
20348 0 : PyObject * obj0 = 0 ;
20349 :
20350 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_sign_result",&obj0)) SWIG_fail;
20351 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_sign_result, SWIG_POINTER_DISOWN | 0 );
20352 0 : if (!SWIG_IsOK(res1)) {
20353 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_sign_result" "', argument " "1"" of type '" "struct _gpgme_op_sign_result *""'");
20354 : }
20355 0 : arg1 = (struct _gpgme_op_sign_result *)(argp1);
20356 : {
20357 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20358 0 : free((char *) arg1);
20359 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20360 : }
20361 0 : resultobj = SWIG_Py_Void();
20362 0 : return resultobj;
20363 : fail:
20364 : return NULL;
20365 : }
20366 :
20367 :
20368 27 : SWIGINTERN PyObject *_gpgme_op_sign_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369 : PyObject *obj;
20370 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
20371 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_sign_result, SWIG_NewClientData(obj));
20372 27 : return SWIG_Py_Void();
20373 : }
20374 :
20375 21 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20376 21 : PyObject *resultobj = 0;
20377 21 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20378 21 : void *argp1 = 0 ;
20379 21 : int res1 = 0 ;
20380 21 : PyObject * obj0 = 0 ;
20381 : gpgme_sign_result_t result;
20382 :
20383 21 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_sign_result",&obj0)) SWIG_fail;
20384 21 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20385 21 : if (!SWIG_IsOK(res1)) {
20386 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20387 : }
20388 21 : arg1 = (gpgme_ctx_t)(argp1);
20389 : {
20390 21 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20391 21 : result = (gpgme_sign_result_t)gpgme_op_sign_result(arg1);
20392 21 : SWIG_PYTHON_THREAD_END_ALLOW;
20393 : }
20394 : {
20395 : PyObject *fragile;
20396 21 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_sign_result,
20397 : 0 );
20398 21 : resultobj = _gpg_wrap_result(fragile, "SignResult");
20399 21 : Py_DECREF(fragile);
20400 : }
20401 : return resultobj;
20402 : fail:
20403 : return NULL;
20404 : }
20405 :
20406 :
20407 0 : SWIGINTERN PyObject *_wrap_gpgme_op_sign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20408 0 : PyObject *resultobj = 0;
20409 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20410 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
20411 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
20412 : gpgme_sig_mode_t arg4 ;
20413 0 : void *argp1 = 0 ;
20414 0 : int res1 = 0 ;
20415 0 : gpgme_data_t wrapper2 = NULL ;
20416 0 : PyObject *bytesio2 = NULL ;
20417 : Py_buffer view2 ;
20418 0 : int have_view2 = 0 ;
20419 0 : gpgme_data_t wrapper3 = NULL ;
20420 0 : PyObject *bytesio3 = NULL ;
20421 : Py_buffer view3 ;
20422 0 : int have_view3 = 0 ;
20423 : int val4 ;
20424 0 : int ecode4 = 0 ;
20425 0 : PyObject * obj0 = 0 ;
20426 0 : PyObject * obj1 = 0 ;
20427 0 : PyObject * obj2 = 0 ;
20428 0 : PyObject * obj3 = 0 ;
20429 : gpgme_error_t result;
20430 :
20431 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20432 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20433 0 : if (!SWIG_IsOK(res1)) {
20434 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20435 : }
20436 0 : arg1 = (gpgme_ctx_t)(argp1);
20437 : {
20438 : /* If we create a temporary wrapper2 object, we will store it in
20439 : wrapperN, where N is 2. Here in this fragment, SWIG will
20440 : automatically append 2. */
20441 0 : memset(&view2, 0, sizeof view2);
20442 0 : if (obj1 == Py_None)
20443 0 : arg2 = NULL;
20444 : else {
20445 : PyObject *pypointer;
20446 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
20447 : &bytesio2, &view2);
20448 0 : if (pypointer == NULL)
20449 : return NULL;
20450 0 : have_view2 = !! view2.obj;
20451 :
20452 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
20453 :
20454 : /* Following code is from swig's python.swg. */
20455 :
20456 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
20457 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20458 0 : Py_DECREF(pypointer);
20459 : return NULL;
20460 : }
20461 0 : Py_DECREF(pypointer);
20462 : }
20463 : }
20464 : {
20465 : /* If we create a temporary wrapper3 object, we will store it in
20466 : wrapperN, where N is 3. Here in this fragment, SWIG will
20467 : automatically append 3. */
20468 0 : memset(&view3, 0, sizeof view3);
20469 0 : if (obj2 == Py_None)
20470 0 : arg3 = NULL;
20471 : else {
20472 : PyObject *pypointer;
20473 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
20474 : &bytesio3, &view3);
20475 0 : if (pypointer == NULL)
20476 : return NULL;
20477 0 : have_view3 = !! view3.obj;
20478 :
20479 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
20480 :
20481 : /* Following code is from swig's python.swg. */
20482 :
20483 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
20484 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20485 0 : Py_DECREF(pypointer);
20486 : return NULL;
20487 : }
20488 0 : Py_DECREF(pypointer);
20489 : }
20490 : }
20491 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
20492 0 : if (!SWIG_IsOK(ecode4)) {
20493 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign_start" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
20494 : }
20495 0 : arg4 = (gpgme_sig_mode_t)(val4);
20496 : {
20497 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20498 0 : result = gpgme_op_sign_start(arg1,arg2,arg3,arg4);
20499 0 : SWIG_PYTHON_THREAD_END_ALLOW;
20500 : }
20501 : {
20502 0 : resultobj = PyLong_FromLong(result);
20503 : }
20504 : {
20505 : /* See whether we need to update the Python buffer. */
20506 0 : if (resultobj && wrapper2 && view2.buf)
20507 : {
20508 : int dirty;
20509 0 : char *new_data = NULL;
20510 : size_t new_size;
20511 :
20512 :
20513 0 : new_data = wrapper2->data.mem.buffer;
20514 0 : new_size = wrapper2->data.mem.length;
20515 0 : dirty = new_data != NULL;
20516 :
20517 :
20518 :
20519 :
20520 :
20521 :
20522 :
20523 0 : if (dirty)
20524 : {
20525 : /* The buffer is dirty. */
20526 0 : if (view2.readonly)
20527 : {
20528 0 : Py_XDECREF(resultobj);
20529 0 : resultobj = NULL;
20530 0 : PyErr_SetString(PyExc_ValueError,
20531 : "cannot update read-only buffer");
20532 : }
20533 :
20534 : /* See if we need to truncate the buffer. */
20535 0 : if (resultobj && view2.len != new_size)
20536 : {
20537 0 : if (bytesio2 == NULL)
20538 : {
20539 0 : Py_XDECREF(resultobj);
20540 0 : resultobj = NULL;
20541 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20542 : }
20543 : else
20544 : {
20545 : PyObject *retval;
20546 0 : PyBuffer_Release(&view2);
20547 : assert(view2.obj == NULL);
20548 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
20549 : "l", (long) new_size);
20550 0 : if (retval == NULL)
20551 : {
20552 0 : Py_XDECREF(resultobj);
20553 : resultobj = NULL;
20554 : }
20555 : else
20556 : {
20557 0 : Py_DECREF(retval);
20558 :
20559 0 : retval = PyObject_CallMethod(bytesio2,
20560 : "getbuffer", NULL);
20561 0 : if (retval == NULL
20562 0 : || PyObject_GetBuffer(retval, &view2,
20563 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20564 : {
20565 0 : Py_XDECREF(resultobj);
20566 : resultobj = NULL;
20567 : }
20568 :
20569 0 : Py_XDECREF(retval);
20570 :
20571 0 : if (resultobj && view2.len
20572 : != new_size)
20573 : {
20574 0 : Py_XDECREF(resultobj);
20575 0 : resultobj = NULL;
20576 0 : PyErr_Format(PyExc_ValueError,
20577 : "Expected buffer of length %zu, got %zi",
20578 : new_size,
20579 : view2.len);
20580 : }
20581 : }
20582 : }
20583 : }
20584 0 : if (resultobj)
20585 0 : memcpy(view2.buf, new_data, new_size);
20586 : }
20587 :
20588 :
20589 :
20590 : }
20591 :
20592 : /* Free the temporary wrapper, if any. */
20593 0 : if (wrapper2)
20594 0 : gpgme_data_release(wrapper2);
20595 0 : Py_XDECREF (bytesio2);
20596 0 : if (have_view2 && view2.buf)
20597 0 : PyBuffer_Release(&view2);
20598 : }
20599 : {
20600 : /* See whether we need to update the Python buffer. */
20601 0 : if (resultobj && wrapper3 && view3.buf)
20602 : {
20603 : int dirty;
20604 0 : char *new_data = NULL;
20605 : size_t new_size;
20606 :
20607 :
20608 0 : new_data = wrapper3->data.mem.buffer;
20609 0 : new_size = wrapper3->data.mem.length;
20610 0 : dirty = new_data != NULL;
20611 :
20612 :
20613 :
20614 :
20615 :
20616 :
20617 :
20618 0 : if (dirty)
20619 : {
20620 : /* The buffer is dirty. */
20621 0 : if (view3.readonly)
20622 : {
20623 0 : Py_XDECREF(resultobj);
20624 0 : resultobj = NULL;
20625 0 : PyErr_SetString(PyExc_ValueError,
20626 : "cannot update read-only buffer");
20627 : }
20628 :
20629 : /* See if we need to truncate the buffer. */
20630 0 : if (resultobj && view3.len != new_size)
20631 : {
20632 0 : if (bytesio3 == NULL)
20633 : {
20634 0 : Py_XDECREF(resultobj);
20635 0 : resultobj = NULL;
20636 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20637 : }
20638 : else
20639 : {
20640 : PyObject *retval;
20641 0 : PyBuffer_Release(&view3);
20642 : assert(view3.obj == NULL);
20643 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
20644 : "l", (long) new_size);
20645 0 : if (retval == NULL)
20646 : {
20647 0 : Py_XDECREF(resultobj);
20648 : resultobj = NULL;
20649 : }
20650 : else
20651 : {
20652 0 : Py_DECREF(retval);
20653 :
20654 0 : retval = PyObject_CallMethod(bytesio3,
20655 : "getbuffer", NULL);
20656 0 : if (retval == NULL
20657 0 : || PyObject_GetBuffer(retval, &view3,
20658 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20659 : {
20660 0 : Py_XDECREF(resultobj);
20661 : resultobj = NULL;
20662 : }
20663 :
20664 0 : Py_XDECREF(retval);
20665 :
20666 0 : if (resultobj && view3.len
20667 : != new_size)
20668 : {
20669 0 : Py_XDECREF(resultobj);
20670 0 : resultobj = NULL;
20671 0 : PyErr_Format(PyExc_ValueError,
20672 : "Expected buffer of length %zu, got %zi",
20673 : new_size,
20674 : view3.len);
20675 : }
20676 : }
20677 : }
20678 : }
20679 0 : if (resultobj)
20680 0 : memcpy(view3.buf, new_data, new_size);
20681 : }
20682 :
20683 :
20684 :
20685 : }
20686 :
20687 : /* Free the temporary wrapper, if any. */
20688 0 : if (wrapper3)
20689 0 : gpgme_data_release(wrapper3);
20690 0 : Py_XDECREF (bytesio3);
20691 0 : if (have_view3 && view3.buf)
20692 0 : PyBuffer_Release(&view3);
20693 : }
20694 : return resultobj;
20695 : fail:
20696 : {
20697 : /* See whether we need to update the Python buffer. */
20698 : if (resultobj && wrapper2 && view2.buf)
20699 : {
20700 : int dirty;
20701 : char *new_data = NULL;
20702 : size_t new_size;
20703 :
20704 :
20705 : new_data = wrapper2->data.mem.buffer;
20706 : new_size = wrapper2->data.mem.length;
20707 : dirty = new_data != NULL;
20708 :
20709 :
20710 :
20711 :
20712 :
20713 :
20714 :
20715 : if (dirty)
20716 : {
20717 : /* The buffer is dirty. */
20718 : if (view2.readonly)
20719 : {
20720 : Py_XDECREF(resultobj);
20721 : resultobj = NULL;
20722 : PyErr_SetString(PyExc_ValueError,
20723 : "cannot update read-only buffer");
20724 : }
20725 :
20726 : /* See if we need to truncate the buffer. */
20727 : if (resultobj && view2.len != new_size)
20728 : {
20729 : if (bytesio2 == NULL)
20730 : {
20731 : Py_XDECREF(resultobj);
20732 : resultobj = NULL;
20733 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20734 : }
20735 : else
20736 : {
20737 : PyObject *retval;
20738 : PyBuffer_Release(&view2);
20739 : assert(view2.obj == NULL);
20740 : retval = PyObject_CallMethod(bytesio2, "truncate",
20741 : "l", (long) new_size);
20742 : if (retval == NULL)
20743 : {
20744 : Py_XDECREF(resultobj);
20745 : resultobj = NULL;
20746 : }
20747 : else
20748 : {
20749 : Py_DECREF(retval);
20750 :
20751 : retval = PyObject_CallMethod(bytesio2,
20752 : "getbuffer", NULL);
20753 : if (retval == NULL
20754 : || PyObject_GetBuffer(retval, &view2,
20755 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20756 : {
20757 : Py_XDECREF(resultobj);
20758 : resultobj = NULL;
20759 : }
20760 :
20761 : Py_XDECREF(retval);
20762 :
20763 : if (resultobj && view2.len
20764 : != new_size)
20765 : {
20766 : Py_XDECREF(resultobj);
20767 : resultobj = NULL;
20768 : PyErr_Format(PyExc_ValueError,
20769 : "Expected buffer of length %zu, got %zi",
20770 : new_size,
20771 : view2.len);
20772 : }
20773 : }
20774 : }
20775 : }
20776 : if (resultobj)
20777 : memcpy(view2.buf, new_data, new_size);
20778 : }
20779 :
20780 :
20781 :
20782 : }
20783 :
20784 : /* Free the temporary wrapper, if any. */
20785 0 : if (wrapper2)
20786 0 : gpgme_data_release(wrapper2);
20787 0 : Py_XDECREF (bytesio2);
20788 0 : if (have_view2 && view2.buf)
20789 0 : PyBuffer_Release(&view2);
20790 : }
20791 : {
20792 : /* See whether we need to update the Python buffer. */
20793 : if (resultobj && wrapper3 && view3.buf)
20794 : {
20795 : int dirty;
20796 : char *new_data = NULL;
20797 : size_t new_size;
20798 :
20799 :
20800 : new_data = wrapper3->data.mem.buffer;
20801 : new_size = wrapper3->data.mem.length;
20802 : dirty = new_data != NULL;
20803 :
20804 :
20805 :
20806 :
20807 :
20808 :
20809 :
20810 : if (dirty)
20811 : {
20812 : /* The buffer is dirty. */
20813 : if (view3.readonly)
20814 : {
20815 : Py_XDECREF(resultobj);
20816 : resultobj = NULL;
20817 : PyErr_SetString(PyExc_ValueError,
20818 : "cannot update read-only buffer");
20819 : }
20820 :
20821 : /* See if we need to truncate the buffer. */
20822 : if (resultobj && view3.len != new_size)
20823 : {
20824 : if (bytesio3 == NULL)
20825 : {
20826 : Py_XDECREF(resultobj);
20827 : resultobj = NULL;
20828 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
20829 : }
20830 : else
20831 : {
20832 : PyObject *retval;
20833 : PyBuffer_Release(&view3);
20834 : assert(view3.obj == NULL);
20835 : retval = PyObject_CallMethod(bytesio3, "truncate",
20836 : "l", (long) new_size);
20837 : if (retval == NULL)
20838 : {
20839 : Py_XDECREF(resultobj);
20840 : resultobj = NULL;
20841 : }
20842 : else
20843 : {
20844 : Py_DECREF(retval);
20845 :
20846 : retval = PyObject_CallMethod(bytesio3,
20847 : "getbuffer", NULL);
20848 : if (retval == NULL
20849 : || PyObject_GetBuffer(retval, &view3,
20850 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
20851 : {
20852 : Py_XDECREF(resultobj);
20853 : resultobj = NULL;
20854 : }
20855 :
20856 : Py_XDECREF(retval);
20857 :
20858 : if (resultobj && view3.len
20859 : != new_size)
20860 : {
20861 : Py_XDECREF(resultobj);
20862 : resultobj = NULL;
20863 : PyErr_Format(PyExc_ValueError,
20864 : "Expected buffer of length %zu, got %zi",
20865 : new_size,
20866 : view3.len);
20867 : }
20868 : }
20869 : }
20870 : }
20871 : if (resultobj)
20872 : memcpy(view3.buf, new_data, new_size);
20873 : }
20874 :
20875 :
20876 :
20877 : }
20878 :
20879 : /* Free the temporary wrapper, if any. */
20880 0 : if (wrapper3)
20881 0 : gpgme_data_release(wrapper3);
20882 0 : Py_XDECREF (bytesio3);
20883 0 : if (have_view3 && view3.buf)
20884 0 : PyBuffer_Release(&view3);
20885 : }
20886 : return NULL;
20887 : }
20888 :
20889 :
20890 16 : SWIGINTERN PyObject *_wrap_gpgme_op_sign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20891 16 : PyObject *resultobj = 0;
20892 16 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
20893 16 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
20894 16 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
20895 : gpgme_sig_mode_t arg4 ;
20896 16 : void *argp1 = 0 ;
20897 16 : int res1 = 0 ;
20898 16 : gpgme_data_t wrapper2 = NULL ;
20899 16 : PyObject *bytesio2 = NULL ;
20900 : Py_buffer view2 ;
20901 16 : int have_view2 = 0 ;
20902 16 : gpgme_data_t wrapper3 = NULL ;
20903 16 : PyObject *bytesio3 = NULL ;
20904 : Py_buffer view3 ;
20905 16 : int have_view3 = 0 ;
20906 : int val4 ;
20907 16 : int ecode4 = 0 ;
20908 16 : PyObject * obj0 = 0 ;
20909 16 : PyObject * obj1 = 0 ;
20910 16 : PyObject * obj2 = 0 ;
20911 16 : PyObject * obj3 = 0 ;
20912 : gpgme_error_t result;
20913 :
20914 16 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_sign",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20915 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
20916 16 : if (!SWIG_IsOK(res1)) {
20917 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_sign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
20918 : }
20919 16 : arg1 = (gpgme_ctx_t)(argp1);
20920 : {
20921 : /* If we create a temporary wrapper2 object, we will store it in
20922 : wrapperN, where N is 2. Here in this fragment, SWIG will
20923 : automatically append 2. */
20924 16 : memset(&view2, 0, sizeof view2);
20925 16 : if (obj1 == Py_None)
20926 0 : arg2 = NULL;
20927 : else {
20928 : PyObject *pypointer;
20929 16 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
20930 : &bytesio2, &view2);
20931 16 : if (pypointer == NULL)
20932 : return NULL;
20933 16 : have_view2 = !! view2.obj;
20934 :
20935 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
20936 :
20937 : /* Following code is from swig's python.swg. */
20938 :
20939 16 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
20940 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20941 0 : Py_DECREF(pypointer);
20942 : return NULL;
20943 : }
20944 16 : Py_DECREF(pypointer);
20945 : }
20946 : }
20947 : {
20948 : /* If we create a temporary wrapper3 object, we will store it in
20949 : wrapperN, where N is 3. Here in this fragment, SWIG will
20950 : automatically append 3. */
20951 16 : memset(&view3, 0, sizeof view3);
20952 16 : if (obj2 == Py_None)
20953 0 : arg3 = NULL;
20954 : else {
20955 : PyObject *pypointer;
20956 16 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
20957 : &bytesio3, &view3);
20958 16 : if (pypointer == NULL)
20959 : return NULL;
20960 16 : have_view3 = !! view3.obj;
20961 :
20962 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
20963 :
20964 : /* Following code is from swig's python.swg. */
20965 :
20966 16 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
20967 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
20968 0 : Py_DECREF(pypointer);
20969 : return NULL;
20970 : }
20971 16 : Py_DECREF(pypointer);
20972 : }
20973 : }
20974 32 : ecode4 = SWIG_AsVal_int(obj3, &val4);
20975 16 : if (!SWIG_IsOK(ecode4)) {
20976 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_sign" "', argument " "4"" of type '" "gpgme_sig_mode_t""'");
20977 : }
20978 16 : arg4 = (gpgme_sig_mode_t)(val4);
20979 : {
20980 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
20981 16 : result = gpgme_op_sign(arg1,arg2,arg3,arg4);
20982 16 : SWIG_PYTHON_THREAD_END_ALLOW;
20983 : }
20984 : {
20985 16 : resultobj = PyLong_FromLong(result);
20986 : }
20987 : {
20988 : /* See whether we need to update the Python buffer. */
20989 16 : if (resultobj && wrapper2 && view2.buf)
20990 : {
20991 : int dirty;
20992 8 : char *new_data = NULL;
20993 : size_t new_size;
20994 :
20995 :
20996 8 : new_data = wrapper2->data.mem.buffer;
20997 8 : new_size = wrapper2->data.mem.length;
20998 8 : dirty = new_data != NULL;
20999 :
21000 :
21001 :
21002 :
21003 :
21004 :
21005 :
21006 8 : if (dirty)
21007 : {
21008 : /* The buffer is dirty. */
21009 0 : if (view2.readonly)
21010 : {
21011 0 : Py_XDECREF(resultobj);
21012 0 : resultobj = NULL;
21013 0 : PyErr_SetString(PyExc_ValueError,
21014 : "cannot update read-only buffer");
21015 : }
21016 :
21017 : /* See if we need to truncate the buffer. */
21018 0 : if (resultobj && view2.len != new_size)
21019 : {
21020 0 : if (bytesio2 == NULL)
21021 : {
21022 0 : Py_XDECREF(resultobj);
21023 0 : resultobj = NULL;
21024 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21025 : }
21026 : else
21027 : {
21028 : PyObject *retval;
21029 0 : PyBuffer_Release(&view2);
21030 : assert(view2.obj == NULL);
21031 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
21032 : "l", (long) new_size);
21033 0 : if (retval == NULL)
21034 : {
21035 0 : Py_XDECREF(resultobj);
21036 : resultobj = NULL;
21037 : }
21038 : else
21039 : {
21040 0 : Py_DECREF(retval);
21041 :
21042 0 : retval = PyObject_CallMethod(bytesio2,
21043 : "getbuffer", NULL);
21044 0 : if (retval == NULL
21045 0 : || PyObject_GetBuffer(retval, &view2,
21046 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21047 : {
21048 0 : Py_XDECREF(resultobj);
21049 : resultobj = NULL;
21050 : }
21051 :
21052 0 : Py_XDECREF(retval);
21053 :
21054 0 : if (resultobj && view2.len
21055 : != new_size)
21056 : {
21057 0 : Py_XDECREF(resultobj);
21058 0 : resultobj = NULL;
21059 0 : PyErr_Format(PyExc_ValueError,
21060 : "Expected buffer of length %zu, got %zi",
21061 : new_size,
21062 : view2.len);
21063 : }
21064 : }
21065 : }
21066 : }
21067 0 : if (resultobj)
21068 0 : memcpy(view2.buf, new_data, new_size);
21069 : }
21070 :
21071 :
21072 :
21073 : }
21074 :
21075 : /* Free the temporary wrapper, if any. */
21076 16 : if (wrapper2)
21077 9 : gpgme_data_release(wrapper2);
21078 16 : Py_XDECREF (bytesio2);
21079 16 : if (have_view2 && view2.buf)
21080 8 : PyBuffer_Release(&view2);
21081 : }
21082 : {
21083 : /* See whether we need to update the Python buffer. */
21084 16 : if (resultobj && wrapper3 && view3.buf)
21085 : {
21086 : int dirty;
21087 0 : char *new_data = NULL;
21088 : size_t new_size;
21089 :
21090 :
21091 0 : new_data = wrapper3->data.mem.buffer;
21092 0 : new_size = wrapper3->data.mem.length;
21093 0 : dirty = new_data != NULL;
21094 :
21095 :
21096 :
21097 :
21098 :
21099 :
21100 :
21101 0 : if (dirty)
21102 : {
21103 : /* The buffer is dirty. */
21104 0 : if (view3.readonly)
21105 : {
21106 0 : Py_XDECREF(resultobj);
21107 0 : resultobj = NULL;
21108 0 : PyErr_SetString(PyExc_ValueError,
21109 : "cannot update read-only buffer");
21110 : }
21111 :
21112 : /* See if we need to truncate the buffer. */
21113 0 : if (resultobj && view3.len != new_size)
21114 : {
21115 0 : if (bytesio3 == NULL)
21116 : {
21117 0 : Py_XDECREF(resultobj);
21118 0 : resultobj = NULL;
21119 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21120 : }
21121 : else
21122 : {
21123 : PyObject *retval;
21124 0 : PyBuffer_Release(&view3);
21125 : assert(view3.obj == NULL);
21126 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
21127 : "l", (long) new_size);
21128 0 : if (retval == NULL)
21129 : {
21130 0 : Py_XDECREF(resultobj);
21131 : resultobj = NULL;
21132 : }
21133 : else
21134 : {
21135 0 : Py_DECREF(retval);
21136 :
21137 0 : retval = PyObject_CallMethod(bytesio3,
21138 : "getbuffer", NULL);
21139 0 : if (retval == NULL
21140 0 : || PyObject_GetBuffer(retval, &view3,
21141 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21142 : {
21143 0 : Py_XDECREF(resultobj);
21144 : resultobj = NULL;
21145 : }
21146 :
21147 0 : Py_XDECREF(retval);
21148 :
21149 0 : if (resultobj && view3.len
21150 : != new_size)
21151 : {
21152 0 : Py_XDECREF(resultobj);
21153 0 : resultobj = NULL;
21154 0 : PyErr_Format(PyExc_ValueError,
21155 : "Expected buffer of length %zu, got %zi",
21156 : new_size,
21157 : view3.len);
21158 : }
21159 : }
21160 : }
21161 : }
21162 0 : if (resultobj)
21163 0 : memcpy(view3.buf, new_data, new_size);
21164 : }
21165 :
21166 :
21167 :
21168 : }
21169 :
21170 : /* Free the temporary wrapper, if any. */
21171 16 : if (wrapper3)
21172 1 : gpgme_data_release(wrapper3);
21173 16 : Py_XDECREF (bytesio3);
21174 16 : if (have_view3 && view3.buf)
21175 0 : PyBuffer_Release(&view3);
21176 : }
21177 : return resultobj;
21178 : fail:
21179 : {
21180 : /* See whether we need to update the Python buffer. */
21181 : if (resultobj && wrapper2 && view2.buf)
21182 : {
21183 : int dirty;
21184 : char *new_data = NULL;
21185 : size_t new_size;
21186 :
21187 :
21188 : new_data = wrapper2->data.mem.buffer;
21189 : new_size = wrapper2->data.mem.length;
21190 : dirty = new_data != NULL;
21191 :
21192 :
21193 :
21194 :
21195 :
21196 :
21197 :
21198 : if (dirty)
21199 : {
21200 : /* The buffer is dirty. */
21201 : if (view2.readonly)
21202 : {
21203 : Py_XDECREF(resultobj);
21204 : resultobj = NULL;
21205 : PyErr_SetString(PyExc_ValueError,
21206 : "cannot update read-only buffer");
21207 : }
21208 :
21209 : /* See if we need to truncate the buffer. */
21210 : if (resultobj && view2.len != new_size)
21211 : {
21212 : if (bytesio2 == NULL)
21213 : {
21214 : Py_XDECREF(resultobj);
21215 : resultobj = NULL;
21216 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21217 : }
21218 : else
21219 : {
21220 : PyObject *retval;
21221 : PyBuffer_Release(&view2);
21222 : assert(view2.obj == NULL);
21223 : retval = PyObject_CallMethod(bytesio2, "truncate",
21224 : "l", (long) new_size);
21225 : if (retval == NULL)
21226 : {
21227 : Py_XDECREF(resultobj);
21228 : resultobj = NULL;
21229 : }
21230 : else
21231 : {
21232 : Py_DECREF(retval);
21233 :
21234 : retval = PyObject_CallMethod(bytesio2,
21235 : "getbuffer", NULL);
21236 : if (retval == NULL
21237 : || PyObject_GetBuffer(retval, &view2,
21238 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21239 : {
21240 : Py_XDECREF(resultobj);
21241 : resultobj = NULL;
21242 : }
21243 :
21244 : Py_XDECREF(retval);
21245 :
21246 : if (resultobj && view2.len
21247 : != new_size)
21248 : {
21249 : Py_XDECREF(resultobj);
21250 : resultobj = NULL;
21251 : PyErr_Format(PyExc_ValueError,
21252 : "Expected buffer of length %zu, got %zi",
21253 : new_size,
21254 : view2.len);
21255 : }
21256 : }
21257 : }
21258 : }
21259 : if (resultobj)
21260 : memcpy(view2.buf, new_data, new_size);
21261 : }
21262 :
21263 :
21264 :
21265 : }
21266 :
21267 : /* Free the temporary wrapper, if any. */
21268 0 : if (wrapper2)
21269 0 : gpgme_data_release(wrapper2);
21270 0 : Py_XDECREF (bytesio2);
21271 0 : if (have_view2 && view2.buf)
21272 0 : PyBuffer_Release(&view2);
21273 : }
21274 : {
21275 : /* See whether we need to update the Python buffer. */
21276 : if (resultobj && wrapper3 && view3.buf)
21277 : {
21278 : int dirty;
21279 : char *new_data = NULL;
21280 : size_t new_size;
21281 :
21282 :
21283 : new_data = wrapper3->data.mem.buffer;
21284 : new_size = wrapper3->data.mem.length;
21285 : dirty = new_data != NULL;
21286 :
21287 :
21288 :
21289 :
21290 :
21291 :
21292 :
21293 : if (dirty)
21294 : {
21295 : /* The buffer is dirty. */
21296 : if (view3.readonly)
21297 : {
21298 : Py_XDECREF(resultobj);
21299 : resultobj = NULL;
21300 : PyErr_SetString(PyExc_ValueError,
21301 : "cannot update read-only buffer");
21302 : }
21303 :
21304 : /* See if we need to truncate the buffer. */
21305 : if (resultobj && view3.len != new_size)
21306 : {
21307 : if (bytesio3 == NULL)
21308 : {
21309 : Py_XDECREF(resultobj);
21310 : resultobj = NULL;
21311 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
21312 : }
21313 : else
21314 : {
21315 : PyObject *retval;
21316 : PyBuffer_Release(&view3);
21317 : assert(view3.obj == NULL);
21318 : retval = PyObject_CallMethod(bytesio3, "truncate",
21319 : "l", (long) new_size);
21320 : if (retval == NULL)
21321 : {
21322 : Py_XDECREF(resultobj);
21323 : resultobj = NULL;
21324 : }
21325 : else
21326 : {
21327 : Py_DECREF(retval);
21328 :
21329 : retval = PyObject_CallMethod(bytesio3,
21330 : "getbuffer", NULL);
21331 : if (retval == NULL
21332 : || PyObject_GetBuffer(retval, &view3,
21333 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
21334 : {
21335 : Py_XDECREF(resultobj);
21336 : resultobj = NULL;
21337 : }
21338 :
21339 : Py_XDECREF(retval);
21340 :
21341 : if (resultobj && view3.len
21342 : != new_size)
21343 : {
21344 : Py_XDECREF(resultobj);
21345 : resultobj = NULL;
21346 : PyErr_Format(PyExc_ValueError,
21347 : "Expected buffer of length %zu, got %zi",
21348 : new_size,
21349 : view3.len);
21350 : }
21351 : }
21352 : }
21353 : }
21354 : if (resultobj)
21355 : memcpy(view3.buf, new_data, new_size);
21356 : }
21357 :
21358 :
21359 :
21360 : }
21361 :
21362 : /* Free the temporary wrapper, if any. */
21363 0 : if (wrapper3)
21364 0 : gpgme_data_release(wrapper3);
21365 0 : Py_XDECREF (bytesio3);
21366 0 : if (have_view3 && view3.buf)
21367 0 : PyBuffer_Release(&view3);
21368 : }
21369 : return NULL;
21370 : }
21371 :
21372 :
21373 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21374 0 : PyObject *resultobj = 0;
21375 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21376 : gpgme_sigsum_t arg2 ;
21377 0 : void *argp1 = 0 ;
21378 0 : int res1 = 0 ;
21379 : int val2 ;
21380 0 : int ecode2 = 0 ;
21381 0 : PyObject * obj0 = 0 ;
21382 0 : PyObject * obj1 = 0 ;
21383 :
21384 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_summary_set",&obj0,&obj1)) SWIG_fail;
21385 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21386 0 : if (!SWIG_IsOK(res1)) {
21387 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21388 : }
21389 0 : arg1 = (struct _gpgme_signature *)(argp1);
21390 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21391 0 : if (!SWIG_IsOK(ecode2)) {
21392 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_summary_set" "', argument " "2"" of type '" "gpgme_sigsum_t""'");
21393 : }
21394 0 : arg2 = (gpgme_sigsum_t)(val2);
21395 : {
21396 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21397 0 : if (arg1) (arg1)->summary = arg2;
21398 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21399 : }
21400 0 : resultobj = SWIG_Py_Void();
21401 0 : return resultobj;
21402 : fail:
21403 : return NULL;
21404 : }
21405 :
21406 :
21407 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_summary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21408 15 : PyObject *resultobj = 0;
21409 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21410 15 : void *argp1 = 0 ;
21411 15 : int res1 = 0 ;
21412 15 : PyObject * obj0 = 0 ;
21413 : gpgme_sigsum_t result;
21414 :
21415 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_summary_get",&obj0)) SWIG_fail;
21416 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21417 15 : if (!SWIG_IsOK(res1)) {
21418 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_summary_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21419 : }
21420 15 : arg1 = (struct _gpgme_signature *)(argp1);
21421 : {
21422 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21423 15 : result = (gpgme_sigsum_t) ((arg1)->summary);
21424 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21425 : }
21426 30 : resultobj = SWIG_From_int((int)(result));
21427 15 : return resultobj;
21428 : fail:
21429 : return NULL;
21430 : }
21431 :
21432 :
21433 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21434 0 : PyObject *resultobj = 0;
21435 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21436 0 : char *arg2 = (char *) 0 ;
21437 0 : void *argp1 = 0 ;
21438 0 : int res1 = 0 ;
21439 : int res2 ;
21440 0 : char *buf2 = 0 ;
21441 0 : int alloc2 = 0 ;
21442 0 : PyObject * obj0 = 0 ;
21443 0 : PyObject * obj1 = 0 ;
21444 :
21445 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_fpr_set",&obj0,&obj1)) SWIG_fail;
21446 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21447 0 : if (!SWIG_IsOK(res1)) {
21448 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21449 : }
21450 0 : arg1 = (struct _gpgme_signature *)(argp1);
21451 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
21452 0 : if (!SWIG_IsOK(res2)) {
21453 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_fpr_set" "', argument " "2"" of type '" "char *""'");
21454 : }
21455 0 : arg2 = (char *)(buf2);
21456 : {
21457 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21458 0 : if (arg1->fpr) free((char*)arg1->fpr);
21459 0 : if (arg2) {
21460 0 : size_t size = strlen((const char *)(arg2)) + 1;
21461 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
21462 : } else {
21463 0 : arg1->fpr = 0;
21464 : }
21465 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21466 : }
21467 0 : resultobj = SWIG_Py_Void();
21468 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21469 : return resultobj;
21470 : fail:
21471 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
21472 : return NULL;
21473 : }
21474 :
21475 :
21476 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21477 15 : PyObject *resultobj = 0;
21478 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21479 15 : void *argp1 = 0 ;
21480 15 : int res1 = 0 ;
21481 15 : PyObject * obj0 = 0 ;
21482 15 : char *result = 0 ;
21483 :
21484 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_fpr_get",&obj0)) SWIG_fail;
21485 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21486 15 : if (!SWIG_IsOK(res1)) {
21487 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_fpr_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21488 : }
21489 15 : arg1 = (struct _gpgme_signature *)(argp1);
21490 : {
21491 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21492 15 : result = (char *) ((arg1)->fpr);
21493 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21494 : }
21495 15 : resultobj = SWIG_FromCharPtr((const char *)result);
21496 15 : return resultobj;
21497 : fail:
21498 : return NULL;
21499 : }
21500 :
21501 :
21502 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 0 : PyObject *resultobj = 0;
21504 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21505 : gpgme_error_t arg2 ;
21506 0 : void *argp1 = 0 ;
21507 0 : int res1 = 0 ;
21508 0 : PyObject * obj0 = 0 ;
21509 0 : PyObject * obj1 = 0 ;
21510 :
21511 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_status_set",&obj0,&obj1)) SWIG_fail;
21512 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21513 0 : if (!SWIG_IsOK(res1)) {
21514 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21515 : }
21516 0 : arg1 = (struct _gpgme_signature *)(argp1);
21517 : {
21518 0 : if (PyLong_Check(obj1))
21519 0 : arg2 = PyLong_AsLong(obj1);
21520 :
21521 0 : else if (PyInt_Check(obj1))
21522 0 : arg2 = PyInt_AsLong(obj1);
21523 :
21524 : else
21525 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
21526 : }
21527 : {
21528 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21529 0 : if (arg1) (arg1)->status = arg2;
21530 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21531 : }
21532 0 : resultobj = SWIG_Py_Void();
21533 0 : return resultobj;
21534 : fail:
21535 : return NULL;
21536 : }
21537 :
21538 :
21539 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21540 15 : PyObject *resultobj = 0;
21541 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21542 15 : void *argp1 = 0 ;
21543 15 : int res1 = 0 ;
21544 15 : PyObject * obj0 = 0 ;
21545 : gpgme_error_t result;
21546 :
21547 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_status_get",&obj0)) SWIG_fail;
21548 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21549 15 : if (!SWIG_IsOK(res1)) {
21550 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_status_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21551 : }
21552 15 : arg1 = (struct _gpgme_signature *)(argp1);
21553 : {
21554 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21555 15 : result = ((arg1)->status);
21556 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21557 : }
21558 : {
21559 15 : resultobj = PyLong_FromLong(result);
21560 : }
21561 15 : return resultobj;
21562 : fail:
21563 : return NULL;
21564 : }
21565 :
21566 :
21567 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21568 0 : PyObject *resultobj = 0;
21569 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21570 0 : gpgme_sig_notation_t arg2 = (gpgme_sig_notation_t) 0 ;
21571 0 : void *argp1 = 0 ;
21572 0 : int res1 = 0 ;
21573 0 : void *argp2 = 0 ;
21574 0 : int res2 = 0 ;
21575 0 : PyObject * obj0 = 0 ;
21576 0 : PyObject * obj1 = 0 ;
21577 :
21578 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_notations_set",&obj0,&obj1)) SWIG_fail;
21579 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21580 0 : if (!SWIG_IsOK(res1)) {
21581 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21582 : }
21583 0 : arg1 = (struct _gpgme_signature *)(argp1);
21584 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_sig_notation, SWIG_POINTER_DISOWN | 0 );
21585 0 : if (!SWIG_IsOK(res2)) {
21586 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_notations_set" "', argument " "2"" of type '" "gpgme_sig_notation_t""'");
21587 : }
21588 0 : arg2 = (gpgme_sig_notation_t)(argp2);
21589 : {
21590 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21591 0 : if (arg1) (arg1)->notations = arg2;
21592 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21593 : }
21594 0 : resultobj = SWIG_Py_Void();
21595 0 : return resultobj;
21596 : fail:
21597 : return NULL;
21598 : }
21599 :
21600 :
21601 30 : SWIGINTERN PyObject *_wrap__gpgme_signature_notations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21602 30 : PyObject *resultobj = 0;
21603 30 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21604 30 : void *argp1 = 0 ;
21605 30 : int res1 = 0 ;
21606 30 : PyObject * obj0 = 0 ;
21607 : gpgme_sig_notation_t result;
21608 :
21609 30 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_notations_get",&obj0)) SWIG_fail;
21610 30 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21611 30 : if (!SWIG_IsOK(res1)) {
21612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_notations_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21613 : }
21614 30 : arg1 = (struct _gpgme_signature *)(argp1);
21615 : {
21616 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21617 30 : result = (gpgme_sig_notation_t) ((arg1)->notations);
21618 30 : SWIG_PYTHON_THREAD_END_ALLOW;
21619 : }
21620 : {
21621 : int i;
21622 30 : int size = 0;
21623 : gpgme_sig_notation_t curr;
21624 60 : for (curr = result; curr != NULL; curr = curr->next) {
21625 30 : size++;
21626 : }
21627 30 : resultobj = PyList_New(size);
21628 60 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
21629 30 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_sig_notation, 0 );
21630 30 : PyList_SetItem(resultobj, i, o);
21631 : }
21632 : }
21633 : return resultobj;
21634 : fail:
21635 : return NULL;
21636 : }
21637 :
21638 :
21639 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21640 0 : PyObject *resultobj = 0;
21641 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21642 : unsigned long arg2 ;
21643 0 : void *argp1 = 0 ;
21644 0 : int res1 = 0 ;
21645 : unsigned long val2 ;
21646 0 : int ecode2 = 0 ;
21647 0 : PyObject * obj0 = 0 ;
21648 0 : PyObject * obj1 = 0 ;
21649 :
21650 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_timestamp_set",&obj0,&obj1)) SWIG_fail;
21651 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21652 0 : if (!SWIG_IsOK(res1)) {
21653 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21654 : }
21655 0 : arg1 = (struct _gpgme_signature *)(argp1);
21656 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
21657 0 : if (!SWIG_IsOK(ecode2)) {
21658 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
21659 : }
21660 0 : arg2 = (unsigned long)(val2);
21661 : {
21662 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21663 0 : if (arg1) (arg1)->timestamp = arg2;
21664 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21665 : }
21666 0 : resultobj = SWIG_Py_Void();
21667 0 : return resultobj;
21668 : fail:
21669 : return NULL;
21670 : }
21671 :
21672 :
21673 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 15 : PyObject *resultobj = 0;
21675 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21676 15 : void *argp1 = 0 ;
21677 15 : int res1 = 0 ;
21678 15 : PyObject * obj0 = 0 ;
21679 : unsigned long result;
21680 :
21681 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_timestamp_get",&obj0)) SWIG_fail;
21682 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21683 15 : if (!SWIG_IsOK(res1)) {
21684 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21685 : }
21686 15 : arg1 = (struct _gpgme_signature *)(argp1);
21687 : {
21688 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21689 15 : result = (unsigned long) ((arg1)->timestamp);
21690 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21691 : }
21692 15 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
21693 15 : return resultobj;
21694 : fail:
21695 : return NULL;
21696 : }
21697 :
21698 :
21699 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21700 0 : PyObject *resultobj = 0;
21701 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21702 : unsigned long arg2 ;
21703 0 : void *argp1 = 0 ;
21704 0 : int res1 = 0 ;
21705 : unsigned long val2 ;
21706 0 : int ecode2 = 0 ;
21707 0 : PyObject * obj0 = 0 ;
21708 0 : PyObject * obj1 = 0 ;
21709 :
21710 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_exp_timestamp_set",&obj0,&obj1)) SWIG_fail;
21711 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21712 0 : if (!SWIG_IsOK(res1)) {
21713 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21714 : }
21715 0 : arg1 = (struct _gpgme_signature *)(argp1);
21716 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
21717 0 : if (!SWIG_IsOK(ecode2)) {
21718 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_exp_timestamp_set" "', argument " "2"" of type '" "unsigned long""'");
21719 : }
21720 0 : arg2 = (unsigned long)(val2);
21721 : {
21722 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21723 0 : if (arg1) (arg1)->exp_timestamp = arg2;
21724 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21725 : }
21726 0 : resultobj = SWIG_Py_Void();
21727 0 : return resultobj;
21728 : fail:
21729 : return NULL;
21730 : }
21731 :
21732 :
21733 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_exp_timestamp_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21734 15 : PyObject *resultobj = 0;
21735 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21736 15 : void *argp1 = 0 ;
21737 15 : int res1 = 0 ;
21738 15 : PyObject * obj0 = 0 ;
21739 : unsigned long result;
21740 :
21741 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_exp_timestamp_get",&obj0)) SWIG_fail;
21742 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21743 15 : if (!SWIG_IsOK(res1)) {
21744 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_exp_timestamp_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21745 : }
21746 15 : arg1 = (struct _gpgme_signature *)(argp1);
21747 : {
21748 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21749 15 : result = (unsigned long) ((arg1)->exp_timestamp);
21750 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21751 : }
21752 15 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
21753 15 : return resultobj;
21754 : fail:
21755 : return NULL;
21756 : }
21757 :
21758 :
21759 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21760 0 : PyObject *resultobj = 0;
21761 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21762 : unsigned int arg2 ;
21763 0 : void *argp1 = 0 ;
21764 0 : int res1 = 0 ;
21765 : unsigned int val2 ;
21766 0 : int ecode2 = 0 ;
21767 0 : PyObject * obj0 = 0 ;
21768 0 : PyObject * obj1 = 0 ;
21769 :
21770 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_wrong_key_usage_set",&obj0,&obj1)) SWIG_fail;
21771 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21772 0 : if (!SWIG_IsOK(res1)) {
21773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21774 : }
21775 0 : arg1 = (struct _gpgme_signature *)(argp1);
21776 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21777 0 : if (!SWIG_IsOK(ecode2)) {
21778 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_wrong_key_usage_set" "', argument " "2"" of type '" "unsigned int""'");
21779 : }
21780 0 : arg2 = (unsigned int)(val2);
21781 : {
21782 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21783 0 : if (arg1) (arg1)->wrong_key_usage = arg2;
21784 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21785 : }
21786 0 : resultobj = SWIG_Py_Void();
21787 0 : return resultobj;
21788 : fail:
21789 : return NULL;
21790 : }
21791 :
21792 :
21793 30 : SWIGINTERN PyObject *_wrap__gpgme_signature_wrong_key_usage_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21794 30 : PyObject *resultobj = 0;
21795 30 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21796 30 : void *argp1 = 0 ;
21797 30 : int res1 = 0 ;
21798 30 : PyObject * obj0 = 0 ;
21799 : unsigned int result;
21800 :
21801 30 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_wrong_key_usage_get",&obj0)) SWIG_fail;
21802 30 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21803 30 : if (!SWIG_IsOK(res1)) {
21804 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_wrong_key_usage_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21805 : }
21806 30 : arg1 = (struct _gpgme_signature *)(argp1);
21807 : {
21808 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21809 30 : result = (unsigned int) ((arg1)->wrong_key_usage);
21810 30 : SWIG_PYTHON_THREAD_END_ALLOW;
21811 : }
21812 30 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21813 30 : return resultobj;
21814 : fail:
21815 : return NULL;
21816 : }
21817 :
21818 :
21819 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21820 0 : PyObject *resultobj = 0;
21821 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21822 : unsigned int arg2 ;
21823 0 : void *argp1 = 0 ;
21824 0 : int res1 = 0 ;
21825 : unsigned int val2 ;
21826 0 : int ecode2 = 0 ;
21827 0 : PyObject * obj0 = 0 ;
21828 0 : PyObject * obj1 = 0 ;
21829 :
21830 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pka_trust_set",&obj0,&obj1)) SWIG_fail;
21831 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21832 0 : if (!SWIG_IsOK(res1)) {
21833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21834 : }
21835 0 : arg1 = (struct _gpgme_signature *)(argp1);
21836 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21837 0 : if (!SWIG_IsOK(ecode2)) {
21838 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pka_trust_set" "', argument " "2"" of type '" "unsigned int""'");
21839 : }
21840 0 : arg2 = (unsigned int)(val2);
21841 : {
21842 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21843 0 : if (arg1) (arg1)->pka_trust = arg2;
21844 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21845 : }
21846 0 : resultobj = SWIG_Py_Void();
21847 0 : return resultobj;
21848 : fail:
21849 : return NULL;
21850 : }
21851 :
21852 :
21853 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21854 15 : PyObject *resultobj = 0;
21855 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21856 15 : void *argp1 = 0 ;
21857 15 : int res1 = 0 ;
21858 15 : PyObject * obj0 = 0 ;
21859 : unsigned int result;
21860 :
21861 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_trust_get",&obj0)) SWIG_fail;
21862 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21863 15 : if (!SWIG_IsOK(res1)) {
21864 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_trust_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21865 : }
21866 15 : arg1 = (struct _gpgme_signature *)(argp1);
21867 : {
21868 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21869 15 : result = (unsigned int) ((arg1)->pka_trust);
21870 15 : SWIG_PYTHON_THREAD_END_ALLOW;
21871 : }
21872 15 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21873 15 : return resultobj;
21874 : fail:
21875 : return NULL;
21876 : }
21877 :
21878 :
21879 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21880 0 : PyObject *resultobj = 0;
21881 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21882 : unsigned int arg2 ;
21883 0 : void *argp1 = 0 ;
21884 0 : int res1 = 0 ;
21885 : unsigned int val2 ;
21886 0 : int ecode2 = 0 ;
21887 0 : PyObject * obj0 = 0 ;
21888 0 : PyObject * obj1 = 0 ;
21889 :
21890 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_chain_model_set",&obj0,&obj1)) SWIG_fail;
21891 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21892 0 : if (!SWIG_IsOK(res1)) {
21893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21894 : }
21895 0 : arg1 = (struct _gpgme_signature *)(argp1);
21896 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
21897 0 : if (!SWIG_IsOK(ecode2)) {
21898 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_chain_model_set" "', argument " "2"" of type '" "unsigned int""'");
21899 : }
21900 0 : arg2 = (unsigned int)(val2);
21901 : {
21902 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21903 0 : if (arg1) (arg1)->chain_model = arg2;
21904 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21905 : }
21906 0 : resultobj = SWIG_Py_Void();
21907 0 : return resultobj;
21908 : fail:
21909 : return NULL;
21910 : }
21911 :
21912 :
21913 30 : SWIGINTERN PyObject *_wrap__gpgme_signature_chain_model_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21914 30 : PyObject *resultobj = 0;
21915 30 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21916 30 : void *argp1 = 0 ;
21917 30 : int res1 = 0 ;
21918 30 : PyObject * obj0 = 0 ;
21919 : unsigned int result;
21920 :
21921 30 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_chain_model_get",&obj0)) SWIG_fail;
21922 30 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21923 30 : if (!SWIG_IsOK(res1)) {
21924 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_chain_model_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21925 : }
21926 30 : arg1 = (struct _gpgme_signature *)(argp1);
21927 : {
21928 30 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21929 30 : result = (unsigned int) ((arg1)->chain_model);
21930 30 : SWIG_PYTHON_THREAD_END_ALLOW;
21931 : }
21932 30 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
21933 30 : return resultobj;
21934 : fail:
21935 : return NULL;
21936 : }
21937 :
21938 :
21939 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21940 0 : PyObject *resultobj = 0;
21941 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21942 : int arg2 ;
21943 0 : void *argp1 = 0 ;
21944 0 : int res1 = 0 ;
21945 : int val2 ;
21946 0 : int ecode2 = 0 ;
21947 0 : PyObject * obj0 = 0 ;
21948 0 : PyObject * obj1 = 0 ;
21949 :
21950 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature__unused_set",&obj0,&obj1)) SWIG_fail;
21951 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21952 0 : if (!SWIG_IsOK(res1)) {
21953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21954 : }
21955 0 : arg1 = (struct _gpgme_signature *)(argp1);
21956 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
21957 0 : if (!SWIG_IsOK(ecode2)) {
21958 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature__unused_set" "', argument " "2"" of type '" "int""'");
21959 : }
21960 0 : arg2 = (int)(val2);
21961 : {
21962 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21963 0 : if (arg1) (arg1)->_unused = arg2;
21964 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21965 : }
21966 0 : resultobj = SWIG_Py_Void();
21967 0 : return resultobj;
21968 : fail:
21969 : return NULL;
21970 : }
21971 :
21972 :
21973 0 : SWIGINTERN PyObject *_wrap__gpgme_signature__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21974 0 : PyObject *resultobj = 0;
21975 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
21976 0 : void *argp1 = 0 ;
21977 0 : int res1 = 0 ;
21978 0 : PyObject * obj0 = 0 ;
21979 : int result;
21980 :
21981 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature__unused_get",&obj0)) SWIG_fail;
21982 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
21983 0 : if (!SWIG_IsOK(res1)) {
21984 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature__unused_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
21985 : }
21986 0 : arg1 = (struct _gpgme_signature *)(argp1);
21987 : {
21988 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
21989 0 : result = (int) ((arg1)->_unused);
21990 0 : SWIG_PYTHON_THREAD_END_ALLOW;
21991 : }
21992 0 : resultobj = SWIG_From_int((int)(result));
21993 0 : return resultobj;
21994 : fail:
21995 : return NULL;
21996 : }
21997 :
21998 :
21999 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 0 : PyObject *resultobj = 0;
22001 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22002 : gpgme_validity_t arg2 ;
22003 0 : void *argp1 = 0 ;
22004 0 : int res1 = 0 ;
22005 : int val2 ;
22006 0 : int ecode2 = 0 ;
22007 0 : PyObject * obj0 = 0 ;
22008 0 : PyObject * obj1 = 0 ;
22009 :
22010 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_validity_set",&obj0,&obj1)) SWIG_fail;
22011 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22012 0 : if (!SWIG_IsOK(res1)) {
22013 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22014 : }
22015 0 : arg1 = (struct _gpgme_signature *)(argp1);
22016 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22017 0 : if (!SWIG_IsOK(ecode2)) {
22018 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_validity_set" "', argument " "2"" of type '" "gpgme_validity_t""'");
22019 : }
22020 0 : arg2 = (gpgme_validity_t)(val2);
22021 : {
22022 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22023 0 : if (arg1) (arg1)->validity = arg2;
22024 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22025 : }
22026 0 : resultobj = SWIG_Py_Void();
22027 0 : return resultobj;
22028 : fail:
22029 : return NULL;
22030 : }
22031 :
22032 :
22033 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22034 15 : PyObject *resultobj = 0;
22035 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22036 15 : void *argp1 = 0 ;
22037 15 : int res1 = 0 ;
22038 15 : PyObject * obj0 = 0 ;
22039 : gpgme_validity_t result;
22040 :
22041 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_get",&obj0)) SWIG_fail;
22042 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22043 15 : if (!SWIG_IsOK(res1)) {
22044 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22045 : }
22046 15 : arg1 = (struct _gpgme_signature *)(argp1);
22047 : {
22048 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22049 15 : result = (gpgme_validity_t) ((arg1)->validity);
22050 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22051 : }
22052 30 : resultobj = SWIG_From_int((int)(result));
22053 15 : return resultobj;
22054 : fail:
22055 : return NULL;
22056 : }
22057 :
22058 :
22059 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22060 0 : PyObject *resultobj = 0;
22061 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22062 : gpgme_error_t arg2 ;
22063 0 : void *argp1 = 0 ;
22064 0 : int res1 = 0 ;
22065 0 : PyObject * obj0 = 0 ;
22066 0 : PyObject * obj1 = 0 ;
22067 :
22068 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_validity_reason_set",&obj0,&obj1)) SWIG_fail;
22069 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22070 0 : if (!SWIG_IsOK(res1)) {
22071 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22072 : }
22073 0 : arg1 = (struct _gpgme_signature *)(argp1);
22074 : {
22075 0 : if (PyLong_Check(obj1))
22076 0 : arg2 = PyLong_AsLong(obj1);
22077 :
22078 0 : else if (PyInt_Check(obj1))
22079 0 : arg2 = PyInt_AsLong(obj1);
22080 :
22081 : else
22082 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
22083 : }
22084 : {
22085 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22086 0 : if (arg1) (arg1)->validity_reason = arg2;
22087 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22088 : }
22089 0 : resultobj = SWIG_Py_Void();
22090 0 : return resultobj;
22091 : fail:
22092 : return NULL;
22093 : }
22094 :
22095 :
22096 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_validity_reason_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22097 15 : PyObject *resultobj = 0;
22098 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22099 15 : void *argp1 = 0 ;
22100 15 : int res1 = 0 ;
22101 15 : PyObject * obj0 = 0 ;
22102 : gpgme_error_t result;
22103 :
22104 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_validity_reason_get",&obj0)) SWIG_fail;
22105 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22106 15 : if (!SWIG_IsOK(res1)) {
22107 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_validity_reason_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22108 : }
22109 15 : arg1 = (struct _gpgme_signature *)(argp1);
22110 : {
22111 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22112 15 : result = ((arg1)->validity_reason);
22113 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22114 : }
22115 : {
22116 15 : resultobj = PyLong_FromLong(result);
22117 : }
22118 15 : return resultobj;
22119 : fail:
22120 : return NULL;
22121 : }
22122 :
22123 :
22124 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22125 0 : PyObject *resultobj = 0;
22126 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22127 : gpgme_pubkey_algo_t arg2 ;
22128 0 : void *argp1 = 0 ;
22129 0 : int res1 = 0 ;
22130 : int val2 ;
22131 0 : int ecode2 = 0 ;
22132 0 : PyObject * obj0 = 0 ;
22133 0 : PyObject * obj1 = 0 ;
22134 :
22135 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pubkey_algo_set",&obj0,&obj1)) SWIG_fail;
22136 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22137 0 : if (!SWIG_IsOK(res1)) {
22138 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22139 : }
22140 0 : arg1 = (struct _gpgme_signature *)(argp1);
22141 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22142 0 : if (!SWIG_IsOK(ecode2)) {
22143 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_pubkey_algo_set" "', argument " "2"" of type '" "gpgme_pubkey_algo_t""'");
22144 : }
22145 0 : arg2 = (gpgme_pubkey_algo_t)(val2);
22146 : {
22147 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22148 0 : if (arg1) (arg1)->pubkey_algo = arg2;
22149 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22150 : }
22151 0 : resultobj = SWIG_Py_Void();
22152 0 : return resultobj;
22153 : fail:
22154 : return NULL;
22155 : }
22156 :
22157 :
22158 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_pubkey_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22159 15 : PyObject *resultobj = 0;
22160 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22161 15 : void *argp1 = 0 ;
22162 15 : int res1 = 0 ;
22163 15 : PyObject * obj0 = 0 ;
22164 : gpgme_pubkey_algo_t result;
22165 :
22166 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pubkey_algo_get",&obj0)) SWIG_fail;
22167 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22168 15 : if (!SWIG_IsOK(res1)) {
22169 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pubkey_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22170 : }
22171 15 : arg1 = (struct _gpgme_signature *)(argp1);
22172 : {
22173 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22174 15 : result = (gpgme_pubkey_algo_t) ((arg1)->pubkey_algo);
22175 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22176 : }
22177 30 : resultobj = SWIG_From_int((int)(result));
22178 15 : return resultobj;
22179 : fail:
22180 : return NULL;
22181 : }
22182 :
22183 :
22184 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22185 0 : PyObject *resultobj = 0;
22186 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22187 : gpgme_hash_algo_t arg2 ;
22188 0 : void *argp1 = 0 ;
22189 0 : int res1 = 0 ;
22190 : int val2 ;
22191 0 : int ecode2 = 0 ;
22192 0 : PyObject * obj0 = 0 ;
22193 0 : PyObject * obj1 = 0 ;
22194 :
22195 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_hash_algo_set",&obj0,&obj1)) SWIG_fail;
22196 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22197 0 : if (!SWIG_IsOK(res1)) {
22198 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22199 : }
22200 0 : arg1 = (struct _gpgme_signature *)(argp1);
22201 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
22202 0 : if (!SWIG_IsOK(ecode2)) {
22203 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_signature_hash_algo_set" "', argument " "2"" of type '" "gpgme_hash_algo_t""'");
22204 : }
22205 0 : arg2 = (gpgme_hash_algo_t)(val2);
22206 : {
22207 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22208 0 : if (arg1) (arg1)->hash_algo = arg2;
22209 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22210 : }
22211 0 : resultobj = SWIG_Py_Void();
22212 0 : return resultobj;
22213 : fail:
22214 : return NULL;
22215 : }
22216 :
22217 :
22218 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_hash_algo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22219 15 : PyObject *resultobj = 0;
22220 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22221 15 : void *argp1 = 0 ;
22222 15 : int res1 = 0 ;
22223 15 : PyObject * obj0 = 0 ;
22224 : gpgme_hash_algo_t result;
22225 :
22226 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_hash_algo_get",&obj0)) SWIG_fail;
22227 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22228 15 : if (!SWIG_IsOK(res1)) {
22229 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_hash_algo_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22230 : }
22231 15 : arg1 = (struct _gpgme_signature *)(argp1);
22232 : {
22233 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22234 15 : result = (gpgme_hash_algo_t) ((arg1)->hash_algo);
22235 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22236 : }
22237 30 : resultobj = SWIG_From_int((int)(result));
22238 15 : return resultobj;
22239 : fail:
22240 : return NULL;
22241 : }
22242 :
22243 :
22244 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22245 0 : PyObject *resultobj = 0;
22246 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22247 0 : char *arg2 = (char *) 0 ;
22248 0 : void *argp1 = 0 ;
22249 0 : int res1 = 0 ;
22250 : int res2 ;
22251 0 : char *buf2 = 0 ;
22252 0 : int alloc2 = 0 ;
22253 0 : PyObject * obj0 = 0 ;
22254 0 : PyObject * obj1 = 0 ;
22255 :
22256 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_pka_address_set",&obj0,&obj1)) SWIG_fail;
22257 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22258 0 : if (!SWIG_IsOK(res1)) {
22259 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22260 : }
22261 0 : arg1 = (struct _gpgme_signature *)(argp1);
22262 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22263 0 : if (!SWIG_IsOK(res2)) {
22264 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_pka_address_set" "', argument " "2"" of type '" "char *""'");
22265 : }
22266 0 : arg2 = (char *)(buf2);
22267 : {
22268 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22269 0 : if (arg1->pka_address) free((char*)arg1->pka_address);
22270 0 : if (arg2) {
22271 0 : size_t size = strlen((const char *)(arg2)) + 1;
22272 0 : arg1->pka_address = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
22273 : } else {
22274 0 : arg1->pka_address = 0;
22275 : }
22276 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22277 : }
22278 0 : resultobj = SWIG_Py_Void();
22279 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22280 : return resultobj;
22281 : fail:
22282 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22283 : return NULL;
22284 : }
22285 :
22286 :
22287 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_pka_address_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22288 15 : PyObject *resultobj = 0;
22289 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22290 15 : void *argp1 = 0 ;
22291 15 : int res1 = 0 ;
22292 15 : PyObject * obj0 = 0 ;
22293 15 : char *result = 0 ;
22294 :
22295 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_pka_address_get",&obj0)) SWIG_fail;
22296 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22297 15 : if (!SWIG_IsOK(res1)) {
22298 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_pka_address_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22299 : }
22300 15 : arg1 = (struct _gpgme_signature *)(argp1);
22301 : {
22302 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22303 15 : result = (char *) ((arg1)->pka_address);
22304 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22305 : }
22306 15 : resultobj = SWIG_FromCharPtr((const char *)result);
22307 15 : return resultobj;
22308 : fail:
22309 : return NULL;
22310 : }
22311 :
22312 :
22313 0 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22314 0 : PyObject *resultobj = 0;
22315 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22316 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
22317 0 : void *argp1 = 0 ;
22318 0 : int res1 = 0 ;
22319 0 : void *argp2 = 0 ;
22320 0 : int res2 = 0 ;
22321 0 : PyObject * obj0 = 0 ;
22322 0 : PyObject * obj1 = 0 ;
22323 :
22324 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_signature_key_set",&obj0,&obj1)) SWIG_fail;
22325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22326 0 : if (!SWIG_IsOK(res1)) {
22327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_set" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22328 : }
22329 0 : arg1 = (struct _gpgme_signature *)(argp1);
22330 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, SWIG_POINTER_DISOWN | 0 );
22331 0 : if (!SWIG_IsOK(res2)) {
22332 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_signature_key_set" "', argument " "2"" of type '" "gpgme_key_t""'");
22333 : }
22334 0 : arg2 = (gpgme_key_t)(argp2);
22335 : {
22336 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22337 0 : if (arg1) (arg1)->key = arg2;
22338 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22339 : }
22340 0 : resultobj = SWIG_Py_Void();
22341 0 : return resultobj;
22342 : fail:
22343 : return NULL;
22344 : }
22345 :
22346 :
22347 15 : SWIGINTERN PyObject *_wrap__gpgme_signature_key_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22348 15 : PyObject *resultobj = 0;
22349 15 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22350 15 : void *argp1 = 0 ;
22351 15 : int res1 = 0 ;
22352 15 : PyObject * obj0 = 0 ;
22353 : gpgme_key_t result;
22354 :
22355 15 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_signature_key_get",&obj0)) SWIG_fail;
22356 15 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, 0 | 0 );
22357 15 : if (!SWIG_IsOK(res1)) {
22358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_signature_key_get" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22359 : }
22360 15 : arg1 = (struct _gpgme_signature *)(argp1);
22361 : {
22362 15 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22363 15 : result = (gpgme_key_t) ((arg1)->key);
22364 15 : SWIG_PYTHON_THREAD_END_ALLOW;
22365 : }
22366 15 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
22367 15 : return resultobj;
22368 : fail:
22369 : return NULL;
22370 : }
22371 :
22372 :
22373 0 : SWIGINTERN PyObject *_wrap_new__gpgme_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22374 0 : PyObject *resultobj = 0;
22375 0 : struct _gpgme_signature *result = 0 ;
22376 :
22377 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_signature")) SWIG_fail;
22378 : {
22379 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22380 0 : result = (struct _gpgme_signature *)calloc(1, sizeof(struct _gpgme_signature));
22381 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22382 : }
22383 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_signature, SWIG_POINTER_NEW | 0 );
22384 0 : return resultobj;
22385 : fail:
22386 : return NULL;
22387 : }
22388 :
22389 :
22390 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_signature(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22391 0 : PyObject *resultobj = 0;
22392 0 : struct _gpgme_signature *arg1 = (struct _gpgme_signature *) 0 ;
22393 0 : void *argp1 = 0 ;
22394 0 : int res1 = 0 ;
22395 0 : PyObject * obj0 = 0 ;
22396 :
22397 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_signature",&obj0)) SWIG_fail;
22398 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
22399 0 : if (!SWIG_IsOK(res1)) {
22400 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_signature" "', argument " "1"" of type '" "struct _gpgme_signature *""'");
22401 : }
22402 0 : arg1 = (struct _gpgme_signature *)(argp1);
22403 : {
22404 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22405 0 : free((char *) arg1);
22406 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22407 : }
22408 0 : resultobj = SWIG_Py_Void();
22409 0 : return resultobj;
22410 : fail:
22411 : return NULL;
22412 : }
22413 :
22414 :
22415 27 : SWIGINTERN PyObject *_gpgme_signature_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22416 : PyObject *obj;
22417 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22418 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_signature, SWIG_NewClientData(obj));
22419 27 : return SWIG_Py_Void();
22420 : }
22421 :
22422 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22423 0 : PyObject *resultobj = 0;
22424 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
22425 0 : gpgme_signature_t arg2 = (gpgme_signature_t) 0 ;
22426 0 : void *argp1 = 0 ;
22427 0 : int res1 = 0 ;
22428 0 : void *argp2 = 0 ;
22429 0 : int res2 = 0 ;
22430 0 : PyObject * obj0 = 0 ;
22431 0 : PyObject * obj1 = 0 ;
22432 :
22433 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result_signatures_set",&obj0,&obj1)) SWIG_fail;
22434 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
22435 0 : if (!SWIG_IsOK(res1)) {
22436 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
22437 : }
22438 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
22439 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_signature, SWIG_POINTER_DISOWN | 0 );
22440 0 : if (!SWIG_IsOK(res2)) {
22441 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_signatures_set" "', argument " "2"" of type '" "gpgme_signature_t""'");
22442 : }
22443 0 : arg2 = (gpgme_signature_t)(argp2);
22444 : {
22445 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22446 0 : if (arg1) (arg1)->signatures = arg2;
22447 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22448 : }
22449 0 : resultobj = SWIG_Py_Void();
22450 0 : return resultobj;
22451 : fail:
22452 : return NULL;
22453 : }
22454 :
22455 :
22456 36 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22457 36 : PyObject *resultobj = 0;
22458 36 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
22459 36 : void *argp1 = 0 ;
22460 36 : int res1 = 0 ;
22461 36 : PyObject * obj0 = 0 ;
22462 : gpgme_signature_t result;
22463 :
22464 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_signatures_get",&obj0)) SWIG_fail;
22465 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
22466 36 : if (!SWIG_IsOK(res1)) {
22467 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
22468 : }
22469 36 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
22470 : {
22471 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22472 36 : result = (gpgme_signature_t) ((arg1)->signatures);
22473 36 : SWIG_PYTHON_THREAD_END_ALLOW;
22474 : }
22475 : {
22476 : int i;
22477 36 : int size = 0;
22478 : gpgme_signature_t curr;
22479 66 : for (curr = result; curr != NULL; curr = curr->next) {
22480 30 : size++;
22481 : }
22482 36 : resultobj = PyList_New(size);
22483 66 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
22484 30 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_signature, 0 );
22485 30 : PyList_SetItem(resultobj, i, o);
22486 : }
22487 : }
22488 : return resultobj;
22489 : fail:
22490 : return NULL;
22491 : }
22492 :
22493 :
22494 0 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22495 0 : PyObject *resultobj = 0;
22496 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
22497 0 : char *arg2 = (char *) 0 ;
22498 0 : void *argp1 = 0 ;
22499 0 : int res1 = 0 ;
22500 : int res2 ;
22501 0 : char *buf2 = 0 ;
22502 0 : int alloc2 = 0 ;
22503 0 : PyObject * obj0 = 0 ;
22504 0 : PyObject * obj1 = 0 ;
22505 :
22506 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_verify_result_file_name_set",&obj0,&obj1)) SWIG_fail;
22507 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
22508 0 : if (!SWIG_IsOK(res1)) {
22509 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_file_name_set" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
22510 : }
22511 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
22512 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
22513 0 : if (!SWIG_IsOK(res2)) {
22514 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_verify_result_file_name_set" "', argument " "2"" of type '" "char *""'");
22515 : }
22516 0 : arg2 = (char *)(buf2);
22517 : {
22518 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22519 0 : if (arg1->file_name) free((char*)arg1->file_name);
22520 0 : if (arg2) {
22521 0 : size_t size = strlen((const char *)(arg2)) + 1;
22522 0 : arg1->file_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
22523 : } else {
22524 0 : arg1->file_name = 0;
22525 : }
22526 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22527 : }
22528 0 : resultobj = SWIG_Py_Void();
22529 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22530 : return resultobj;
22531 : fail:
22532 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
22533 : return NULL;
22534 : }
22535 :
22536 :
22537 18 : SWIGINTERN PyObject *_wrap__gpgme_op_verify_result_file_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22538 18 : PyObject *resultobj = 0;
22539 18 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
22540 18 : void *argp1 = 0 ;
22541 18 : int res1 = 0 ;
22542 18 : PyObject * obj0 = 0 ;
22543 18 : char *result = 0 ;
22544 :
22545 18 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_verify_result_file_name_get",&obj0)) SWIG_fail;
22546 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, 0 | 0 );
22547 18 : if (!SWIG_IsOK(res1)) {
22548 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_verify_result_file_name_get" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
22549 : }
22550 18 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
22551 : {
22552 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22553 18 : result = (char *) ((arg1)->file_name);
22554 18 : SWIG_PYTHON_THREAD_END_ALLOW;
22555 : }
22556 18 : resultobj = SWIG_FromCharPtr((const char *)result);
22557 18 : return resultobj;
22558 : fail:
22559 : return NULL;
22560 : }
22561 :
22562 :
22563 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22564 0 : PyObject *resultobj = 0;
22565 0 : struct _gpgme_op_verify_result *result = 0 ;
22566 :
22567 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_verify_result")) SWIG_fail;
22568 : {
22569 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22570 0 : result = (struct _gpgme_op_verify_result *)calloc(1, sizeof(struct _gpgme_op_verify_result));
22571 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22572 : }
22573 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result, SWIG_POINTER_NEW | 0 );
22574 0 : return resultobj;
22575 : fail:
22576 : return NULL;
22577 : }
22578 :
22579 :
22580 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22581 0 : PyObject *resultobj = 0;
22582 0 : struct _gpgme_op_verify_result *arg1 = (struct _gpgme_op_verify_result *) 0 ;
22583 0 : void *argp1 = 0 ;
22584 0 : int res1 = 0 ;
22585 0 : PyObject * obj0 = 0 ;
22586 :
22587 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_verify_result",&obj0)) SWIG_fail;
22588 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_verify_result, SWIG_POINTER_DISOWN | 0 );
22589 0 : if (!SWIG_IsOK(res1)) {
22590 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_verify_result" "', argument " "1"" of type '" "struct _gpgme_op_verify_result *""'");
22591 : }
22592 0 : arg1 = (struct _gpgme_op_verify_result *)(argp1);
22593 : {
22594 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22595 0 : free((char *) arg1);
22596 0 : SWIG_PYTHON_THREAD_END_ALLOW;
22597 : }
22598 0 : resultobj = SWIG_Py_Void();
22599 0 : return resultobj;
22600 : fail:
22601 : return NULL;
22602 : }
22603 :
22604 :
22605 27 : SWIGINTERN PyObject *_gpgme_op_verify_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22606 : PyObject *obj;
22607 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
22608 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_verify_result, SWIG_NewClientData(obj));
22609 27 : return SWIG_Py_Void();
22610 : }
22611 :
22612 18 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22613 18 : PyObject *resultobj = 0;
22614 18 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22615 18 : void *argp1 = 0 ;
22616 18 : int res1 = 0 ;
22617 18 : PyObject * obj0 = 0 ;
22618 : gpgme_verify_result_t result;
22619 :
22620 18 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_verify_result",&obj0)) SWIG_fail;
22621 18 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22622 18 : if (!SWIG_IsOK(res1)) {
22623 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22624 : }
22625 18 : arg1 = (gpgme_ctx_t)(argp1);
22626 : {
22627 18 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22628 18 : result = (gpgme_verify_result_t)gpgme_op_verify_result(arg1);
22629 18 : SWIG_PYTHON_THREAD_END_ALLOW;
22630 : }
22631 : {
22632 : PyObject *fragile;
22633 18 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_verify_result,
22634 : 0 );
22635 18 : resultobj = _gpg_wrap_result(fragile, "VerifyResult");
22636 18 : Py_DECREF(fragile);
22637 : }
22638 : return resultobj;
22639 : fail:
22640 : return NULL;
22641 : }
22642 :
22643 :
22644 1 : SWIGINTERN PyObject *_wrap_gpgme_op_verify_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22645 1 : PyObject *resultobj = 0;
22646 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
22647 1 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
22648 1 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
22649 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
22650 1 : void *argp1 = 0 ;
22651 1 : int res1 = 0 ;
22652 1 : gpgme_data_t wrapper2 = NULL ;
22653 1 : PyObject *bytesio2 = NULL ;
22654 : Py_buffer view2 ;
22655 1 : int have_view2 = 0 ;
22656 1 : gpgme_data_t wrapper3 = NULL ;
22657 1 : PyObject *bytesio3 = NULL ;
22658 : Py_buffer view3 ;
22659 1 : int have_view3 = 0 ;
22660 1 : gpgme_data_t wrapper4 = NULL ;
22661 1 : PyObject *bytesio4 = NULL ;
22662 : Py_buffer view4 ;
22663 1 : int have_view4 = 0 ;
22664 1 : PyObject * obj0 = 0 ;
22665 1 : PyObject * obj1 = 0 ;
22666 1 : PyObject * obj2 = 0 ;
22667 1 : PyObject * obj3 = 0 ;
22668 : gpgme_error_t result;
22669 :
22670 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22671 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
22672 1 : if (!SWIG_IsOK(res1)) {
22673 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
22674 : }
22675 1 : arg1 = (gpgme_ctx_t)(argp1);
22676 : {
22677 : /* If we create a temporary wrapper2 object, we will store it in
22678 : wrapperN, where N is 2. Here in this fragment, SWIG will
22679 : automatically append 2. */
22680 1 : memset(&view2, 0, sizeof view2);
22681 1 : if (obj1 == Py_None)
22682 0 : arg2 = NULL;
22683 : else {
22684 : PyObject *pypointer;
22685 1 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
22686 : &bytesio2, &view2);
22687 1 : if (pypointer == NULL)
22688 : return NULL;
22689 1 : have_view2 = !! view2.obj;
22690 :
22691 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
22692 :
22693 : /* Following code is from swig's python.swg. */
22694 :
22695 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
22696 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22697 0 : Py_DECREF(pypointer);
22698 : return NULL;
22699 : }
22700 1 : Py_DECREF(pypointer);
22701 : }
22702 : }
22703 : {
22704 : /* If we create a temporary wrapper3 object, we will store it in
22705 : wrapperN, where N is 3. Here in this fragment, SWIG will
22706 : automatically append 3. */
22707 1 : memset(&view3, 0, sizeof view3);
22708 1 : if (obj2 == Py_None)
22709 1 : arg3 = NULL;
22710 : else {
22711 : PyObject *pypointer;
22712 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
22713 : &bytesio3, &view3);
22714 0 : if (pypointer == NULL)
22715 : return NULL;
22716 0 : have_view3 = !! view3.obj;
22717 :
22718 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
22719 :
22720 : /* Following code is from swig's python.swg. */
22721 :
22722 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
22723 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22724 0 : Py_DECREF(pypointer);
22725 : return NULL;
22726 : }
22727 0 : Py_DECREF(pypointer);
22728 : }
22729 : }
22730 : {
22731 : /* If we create a temporary wrapper4 object, we will store it in
22732 : wrapperN, where N is 4. Here in this fragment, SWIG will
22733 : automatically append 4. */
22734 1 : memset(&view4, 0, sizeof view4);
22735 1 : if (obj3 == Py_None)
22736 0 : arg4 = NULL;
22737 : else {
22738 : PyObject *pypointer;
22739 1 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
22740 : &bytesio4, &view4);
22741 1 : if (pypointer == NULL)
22742 : return NULL;
22743 1 : have_view4 = !! view4.obj;
22744 :
22745 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
22746 :
22747 : /* Following code is from swig's python.swg. */
22748 :
22749 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
22750 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
22751 0 : Py_DECREF(pypointer);
22752 : return NULL;
22753 : }
22754 1 : Py_DECREF(pypointer);
22755 : }
22756 : }
22757 : {
22758 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
22759 1 : result = gpgme_op_verify_start(arg1,arg2,arg3,arg4);
22760 1 : SWIG_PYTHON_THREAD_END_ALLOW;
22761 : }
22762 : {
22763 1 : resultobj = PyLong_FromLong(result);
22764 : }
22765 : {
22766 : /* See whether we need to update the Python buffer. */
22767 1 : if (resultobj && wrapper2 && view2.buf)
22768 : {
22769 : int dirty;
22770 0 : char *new_data = NULL;
22771 : size_t new_size;
22772 :
22773 :
22774 0 : new_data = wrapper2->data.mem.buffer;
22775 0 : new_size = wrapper2->data.mem.length;
22776 0 : dirty = new_data != NULL;
22777 :
22778 :
22779 :
22780 :
22781 :
22782 :
22783 :
22784 0 : if (dirty)
22785 : {
22786 : /* The buffer is dirty. */
22787 0 : if (view2.readonly)
22788 : {
22789 0 : Py_XDECREF(resultobj);
22790 0 : resultobj = NULL;
22791 0 : PyErr_SetString(PyExc_ValueError,
22792 : "cannot update read-only buffer");
22793 : }
22794 :
22795 : /* See if we need to truncate the buffer. */
22796 0 : if (resultobj && view2.len != new_size)
22797 : {
22798 0 : if (bytesio2 == NULL)
22799 : {
22800 0 : Py_XDECREF(resultobj);
22801 0 : resultobj = NULL;
22802 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22803 : }
22804 : else
22805 : {
22806 : PyObject *retval;
22807 0 : PyBuffer_Release(&view2);
22808 : assert(view2.obj == NULL);
22809 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
22810 : "l", (long) new_size);
22811 0 : if (retval == NULL)
22812 : {
22813 0 : Py_XDECREF(resultobj);
22814 : resultobj = NULL;
22815 : }
22816 : else
22817 : {
22818 0 : Py_DECREF(retval);
22819 :
22820 0 : retval = PyObject_CallMethod(bytesio2,
22821 : "getbuffer", NULL);
22822 0 : if (retval == NULL
22823 0 : || PyObject_GetBuffer(retval, &view2,
22824 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22825 : {
22826 0 : Py_XDECREF(resultobj);
22827 : resultobj = NULL;
22828 : }
22829 :
22830 0 : Py_XDECREF(retval);
22831 :
22832 0 : if (resultobj && view2.len
22833 : != new_size)
22834 : {
22835 0 : Py_XDECREF(resultobj);
22836 0 : resultobj = NULL;
22837 0 : PyErr_Format(PyExc_ValueError,
22838 : "Expected buffer of length %zu, got %zi",
22839 : new_size,
22840 : view2.len);
22841 : }
22842 : }
22843 : }
22844 : }
22845 0 : if (resultobj)
22846 0 : memcpy(view2.buf, new_data, new_size);
22847 : }
22848 :
22849 :
22850 :
22851 : }
22852 :
22853 : /* Free the temporary wrapper, if any. */
22854 1 : if (wrapper2)
22855 0 : gpgme_data_release(wrapper2);
22856 1 : Py_XDECREF (bytesio2);
22857 1 : if (have_view2 && view2.buf)
22858 0 : PyBuffer_Release(&view2);
22859 : }
22860 : {
22861 : /* See whether we need to update the Python buffer. */
22862 1 : if (resultobj && wrapper3 && view3.buf)
22863 : {
22864 : int dirty;
22865 0 : char *new_data = NULL;
22866 : size_t new_size;
22867 :
22868 :
22869 0 : new_data = wrapper3->data.mem.buffer;
22870 0 : new_size = wrapper3->data.mem.length;
22871 0 : dirty = new_data != NULL;
22872 :
22873 :
22874 :
22875 :
22876 :
22877 :
22878 :
22879 0 : if (dirty)
22880 : {
22881 : /* The buffer is dirty. */
22882 0 : if (view3.readonly)
22883 : {
22884 0 : Py_XDECREF(resultobj);
22885 0 : resultobj = NULL;
22886 0 : PyErr_SetString(PyExc_ValueError,
22887 : "cannot update read-only buffer");
22888 : }
22889 :
22890 : /* See if we need to truncate the buffer. */
22891 0 : if (resultobj && view3.len != new_size)
22892 : {
22893 0 : if (bytesio3 == NULL)
22894 : {
22895 0 : Py_XDECREF(resultobj);
22896 0 : resultobj = NULL;
22897 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22898 : }
22899 : else
22900 : {
22901 : PyObject *retval;
22902 0 : PyBuffer_Release(&view3);
22903 : assert(view3.obj == NULL);
22904 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
22905 : "l", (long) new_size);
22906 0 : if (retval == NULL)
22907 : {
22908 0 : Py_XDECREF(resultobj);
22909 : resultobj = NULL;
22910 : }
22911 : else
22912 : {
22913 0 : Py_DECREF(retval);
22914 :
22915 0 : retval = PyObject_CallMethod(bytesio3,
22916 : "getbuffer", NULL);
22917 0 : if (retval == NULL
22918 0 : || PyObject_GetBuffer(retval, &view3,
22919 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
22920 : {
22921 0 : Py_XDECREF(resultobj);
22922 : resultobj = NULL;
22923 : }
22924 :
22925 0 : Py_XDECREF(retval);
22926 :
22927 0 : if (resultobj && view3.len
22928 : != new_size)
22929 : {
22930 0 : Py_XDECREF(resultobj);
22931 0 : resultobj = NULL;
22932 0 : PyErr_Format(PyExc_ValueError,
22933 : "Expected buffer of length %zu, got %zi",
22934 : new_size,
22935 : view3.len);
22936 : }
22937 : }
22938 : }
22939 : }
22940 0 : if (resultobj)
22941 0 : memcpy(view3.buf, new_data, new_size);
22942 : }
22943 :
22944 :
22945 :
22946 : }
22947 :
22948 : /* Free the temporary wrapper, if any. */
22949 1 : if (wrapper3)
22950 0 : gpgme_data_release(wrapper3);
22951 1 : Py_XDECREF (bytesio3);
22952 1 : if (have_view3 && view3.buf)
22953 0 : PyBuffer_Release(&view3);
22954 : }
22955 : {
22956 : /* See whether we need to update the Python buffer. */
22957 1 : if (resultobj && wrapper4 && view4.buf)
22958 : {
22959 : int dirty;
22960 0 : char *new_data = NULL;
22961 : size_t new_size;
22962 :
22963 :
22964 0 : new_data = wrapper4->data.mem.buffer;
22965 0 : new_size = wrapper4->data.mem.length;
22966 0 : dirty = new_data != NULL;
22967 :
22968 :
22969 :
22970 :
22971 :
22972 :
22973 :
22974 0 : if (dirty)
22975 : {
22976 : /* The buffer is dirty. */
22977 0 : if (view4.readonly)
22978 : {
22979 0 : Py_XDECREF(resultobj);
22980 0 : resultobj = NULL;
22981 0 : PyErr_SetString(PyExc_ValueError,
22982 : "cannot update read-only buffer");
22983 : }
22984 :
22985 : /* See if we need to truncate the buffer. */
22986 0 : if (resultobj && view4.len != new_size)
22987 : {
22988 0 : if (bytesio4 == NULL)
22989 : {
22990 0 : Py_XDECREF(resultobj);
22991 0 : resultobj = NULL;
22992 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
22993 : }
22994 : else
22995 : {
22996 : PyObject *retval;
22997 0 : PyBuffer_Release(&view4);
22998 : assert(view4.obj == NULL);
22999 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23000 : "l", (long) new_size);
23001 0 : if (retval == NULL)
23002 : {
23003 0 : Py_XDECREF(resultobj);
23004 : resultobj = NULL;
23005 : }
23006 : else
23007 : {
23008 0 : Py_DECREF(retval);
23009 :
23010 0 : retval = PyObject_CallMethod(bytesio4,
23011 : "getbuffer", NULL);
23012 0 : if (retval == NULL
23013 0 : || PyObject_GetBuffer(retval, &view4,
23014 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23015 : {
23016 0 : Py_XDECREF(resultobj);
23017 : resultobj = NULL;
23018 : }
23019 :
23020 0 : Py_XDECREF(retval);
23021 :
23022 0 : if (resultobj && view4.len
23023 : != new_size)
23024 : {
23025 0 : Py_XDECREF(resultobj);
23026 0 : resultobj = NULL;
23027 0 : PyErr_Format(PyExc_ValueError,
23028 : "Expected buffer of length %zu, got %zi",
23029 : new_size,
23030 : view4.len);
23031 : }
23032 : }
23033 : }
23034 : }
23035 0 : if (resultobj)
23036 0 : memcpy(view4.buf, new_data, new_size);
23037 : }
23038 :
23039 :
23040 :
23041 : }
23042 :
23043 : /* Free the temporary wrapper, if any. */
23044 1 : if (wrapper4)
23045 0 : gpgme_data_release(wrapper4);
23046 1 : Py_XDECREF (bytesio4);
23047 1 : if (have_view4 && view4.buf)
23048 0 : PyBuffer_Release(&view4);
23049 : }
23050 : return resultobj;
23051 : fail:
23052 : {
23053 : /* See whether we need to update the Python buffer. */
23054 : if (resultobj && wrapper2 && view2.buf)
23055 : {
23056 : int dirty;
23057 : char *new_data = NULL;
23058 : size_t new_size;
23059 :
23060 :
23061 : new_data = wrapper2->data.mem.buffer;
23062 : new_size = wrapper2->data.mem.length;
23063 : dirty = new_data != NULL;
23064 :
23065 :
23066 :
23067 :
23068 :
23069 :
23070 :
23071 : if (dirty)
23072 : {
23073 : /* The buffer is dirty. */
23074 : if (view2.readonly)
23075 : {
23076 : Py_XDECREF(resultobj);
23077 : resultobj = NULL;
23078 : PyErr_SetString(PyExc_ValueError,
23079 : "cannot update read-only buffer");
23080 : }
23081 :
23082 : /* See if we need to truncate the buffer. */
23083 : if (resultobj && view2.len != new_size)
23084 : {
23085 : if (bytesio2 == NULL)
23086 : {
23087 : Py_XDECREF(resultobj);
23088 : resultobj = NULL;
23089 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23090 : }
23091 : else
23092 : {
23093 : PyObject *retval;
23094 : PyBuffer_Release(&view2);
23095 : assert(view2.obj == NULL);
23096 : retval = PyObject_CallMethod(bytesio2, "truncate",
23097 : "l", (long) new_size);
23098 : if (retval == NULL)
23099 : {
23100 : Py_XDECREF(resultobj);
23101 : resultobj = NULL;
23102 : }
23103 : else
23104 : {
23105 : Py_DECREF(retval);
23106 :
23107 : retval = PyObject_CallMethod(bytesio2,
23108 : "getbuffer", NULL);
23109 : if (retval == NULL
23110 : || PyObject_GetBuffer(retval, &view2,
23111 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23112 : {
23113 : Py_XDECREF(resultobj);
23114 : resultobj = NULL;
23115 : }
23116 :
23117 : Py_XDECREF(retval);
23118 :
23119 : if (resultobj && view2.len
23120 : != new_size)
23121 : {
23122 : Py_XDECREF(resultobj);
23123 : resultobj = NULL;
23124 : PyErr_Format(PyExc_ValueError,
23125 : "Expected buffer of length %zu, got %zi",
23126 : new_size,
23127 : view2.len);
23128 : }
23129 : }
23130 : }
23131 : }
23132 : if (resultobj)
23133 : memcpy(view2.buf, new_data, new_size);
23134 : }
23135 :
23136 :
23137 :
23138 : }
23139 :
23140 : /* Free the temporary wrapper, if any. */
23141 0 : if (wrapper2)
23142 0 : gpgme_data_release(wrapper2);
23143 0 : Py_XDECREF (bytesio2);
23144 : if (have_view2 && view2.buf)
23145 : PyBuffer_Release(&view2);
23146 : }
23147 : {
23148 : /* See whether we need to update the Python buffer. */
23149 : if (resultobj && wrapper3 && view3.buf)
23150 : {
23151 : int dirty;
23152 : char *new_data = NULL;
23153 : size_t new_size;
23154 :
23155 :
23156 : new_data = wrapper3->data.mem.buffer;
23157 : new_size = wrapper3->data.mem.length;
23158 : dirty = new_data != NULL;
23159 :
23160 :
23161 :
23162 :
23163 :
23164 :
23165 :
23166 : if (dirty)
23167 : {
23168 : /* The buffer is dirty. */
23169 : if (view3.readonly)
23170 : {
23171 : Py_XDECREF(resultobj);
23172 : resultobj = NULL;
23173 : PyErr_SetString(PyExc_ValueError,
23174 : "cannot update read-only buffer");
23175 : }
23176 :
23177 : /* See if we need to truncate the buffer. */
23178 : if (resultobj && view3.len != new_size)
23179 : {
23180 : if (bytesio3 == NULL)
23181 : {
23182 : Py_XDECREF(resultobj);
23183 : resultobj = NULL;
23184 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23185 : }
23186 : else
23187 : {
23188 : PyObject *retval;
23189 : PyBuffer_Release(&view3);
23190 : assert(view3.obj == NULL);
23191 : retval = PyObject_CallMethod(bytesio3, "truncate",
23192 : "l", (long) new_size);
23193 : if (retval == NULL)
23194 : {
23195 : Py_XDECREF(resultobj);
23196 : resultobj = NULL;
23197 : }
23198 : else
23199 : {
23200 : Py_DECREF(retval);
23201 :
23202 : retval = PyObject_CallMethod(bytesio3,
23203 : "getbuffer", NULL);
23204 : if (retval == NULL
23205 : || PyObject_GetBuffer(retval, &view3,
23206 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23207 : {
23208 : Py_XDECREF(resultobj);
23209 : resultobj = NULL;
23210 : }
23211 :
23212 : Py_XDECREF(retval);
23213 :
23214 : if (resultobj && view3.len
23215 : != new_size)
23216 : {
23217 : Py_XDECREF(resultobj);
23218 : resultobj = NULL;
23219 : PyErr_Format(PyExc_ValueError,
23220 : "Expected buffer of length %zu, got %zi",
23221 : new_size,
23222 : view3.len);
23223 : }
23224 : }
23225 : }
23226 : }
23227 : if (resultobj)
23228 : memcpy(view3.buf, new_data, new_size);
23229 : }
23230 :
23231 :
23232 :
23233 : }
23234 :
23235 : /* Free the temporary wrapper, if any. */
23236 0 : if (wrapper3)
23237 0 : gpgme_data_release(wrapper3);
23238 0 : Py_XDECREF (bytesio3);
23239 : if (have_view3 && view3.buf)
23240 : PyBuffer_Release(&view3);
23241 : }
23242 : {
23243 : /* See whether we need to update the Python buffer. */
23244 : if (resultobj && wrapper4 && view4.buf)
23245 : {
23246 : int dirty;
23247 : char *new_data = NULL;
23248 : size_t new_size;
23249 :
23250 :
23251 : new_data = wrapper4->data.mem.buffer;
23252 : new_size = wrapper4->data.mem.length;
23253 : dirty = new_data != NULL;
23254 :
23255 :
23256 :
23257 :
23258 :
23259 :
23260 :
23261 : if (dirty)
23262 : {
23263 : /* The buffer is dirty. */
23264 : if (view4.readonly)
23265 : {
23266 : Py_XDECREF(resultobj);
23267 : resultobj = NULL;
23268 : PyErr_SetString(PyExc_ValueError,
23269 : "cannot update read-only buffer");
23270 : }
23271 :
23272 : /* See if we need to truncate the buffer. */
23273 : if (resultobj && view4.len != new_size)
23274 : {
23275 : if (bytesio4 == NULL)
23276 : {
23277 : Py_XDECREF(resultobj);
23278 : resultobj = NULL;
23279 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23280 : }
23281 : else
23282 : {
23283 : PyObject *retval;
23284 : PyBuffer_Release(&view4);
23285 : assert(view4.obj == NULL);
23286 : retval = PyObject_CallMethod(bytesio4, "truncate",
23287 : "l", (long) new_size);
23288 : if (retval == NULL)
23289 : {
23290 : Py_XDECREF(resultobj);
23291 : resultobj = NULL;
23292 : }
23293 : else
23294 : {
23295 : Py_DECREF(retval);
23296 :
23297 : retval = PyObject_CallMethod(bytesio4,
23298 : "getbuffer", NULL);
23299 : if (retval == NULL
23300 : || PyObject_GetBuffer(retval, &view4,
23301 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23302 : {
23303 : Py_XDECREF(resultobj);
23304 : resultobj = NULL;
23305 : }
23306 :
23307 : Py_XDECREF(retval);
23308 :
23309 : if (resultobj && view4.len
23310 : != new_size)
23311 : {
23312 : Py_XDECREF(resultobj);
23313 : resultobj = NULL;
23314 : PyErr_Format(PyExc_ValueError,
23315 : "Expected buffer of length %zu, got %zi",
23316 : new_size,
23317 : view4.len);
23318 : }
23319 : }
23320 : }
23321 : }
23322 : if (resultobj)
23323 : memcpy(view4.buf, new_data, new_size);
23324 : }
23325 :
23326 :
23327 :
23328 : }
23329 :
23330 : /* Free the temporary wrapper, if any. */
23331 0 : if (wrapper4)
23332 0 : gpgme_data_release(wrapper4);
23333 0 : Py_XDECREF (bytesio4);
23334 : if (have_view4 && view4.buf)
23335 : PyBuffer_Release(&view4);
23336 : }
23337 : return NULL;
23338 : }
23339 :
23340 :
23341 12 : SWIGINTERN PyObject *_wrap_gpgme_op_verify(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23342 12 : PyObject *resultobj = 0;
23343 12 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
23344 12 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
23345 12 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
23346 12 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
23347 12 : void *argp1 = 0 ;
23348 12 : int res1 = 0 ;
23349 12 : gpgme_data_t wrapper2 = NULL ;
23350 12 : PyObject *bytesio2 = NULL ;
23351 : Py_buffer view2 ;
23352 12 : int have_view2 = 0 ;
23353 12 : gpgme_data_t wrapper3 = NULL ;
23354 12 : PyObject *bytesio3 = NULL ;
23355 : Py_buffer view3 ;
23356 12 : int have_view3 = 0 ;
23357 12 : gpgme_data_t wrapper4 = NULL ;
23358 12 : PyObject *bytesio4 = NULL ;
23359 : Py_buffer view4 ;
23360 12 : int have_view4 = 0 ;
23361 12 : PyObject * obj0 = 0 ;
23362 12 : PyObject * obj1 = 0 ;
23363 12 : PyObject * obj2 = 0 ;
23364 12 : PyObject * obj3 = 0 ;
23365 : gpgme_error_t result;
23366 :
23367 12 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_verify",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
23368 12 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
23369 12 : if (!SWIG_IsOK(res1)) {
23370 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_verify" "', argument " "1"" of type '" "gpgme_ctx_t""'");
23371 : }
23372 12 : arg1 = (gpgme_ctx_t)(argp1);
23373 : {
23374 : /* If we create a temporary wrapper2 object, we will store it in
23375 : wrapperN, where N is 2. Here in this fragment, SWIG will
23376 : automatically append 2. */
23377 12 : memset(&view2, 0, sizeof view2);
23378 12 : if (obj1 == Py_None)
23379 0 : arg2 = NULL;
23380 : else {
23381 : PyObject *pypointer;
23382 12 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
23383 : &bytesio2, &view2);
23384 12 : if (pypointer == NULL)
23385 : return NULL;
23386 12 : have_view2 = !! view2.obj;
23387 :
23388 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
23389 :
23390 : /* Following code is from swig's python.swg. */
23391 :
23392 12 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
23393 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23394 0 : Py_DECREF(pypointer);
23395 : return NULL;
23396 : }
23397 12 : Py_DECREF(pypointer);
23398 : }
23399 : }
23400 : {
23401 : /* If we create a temporary wrapper3 object, we will store it in
23402 : wrapperN, where N is 3. Here in this fragment, SWIG will
23403 : automatically append 3. */
23404 12 : memset(&view3, 0, sizeof view3);
23405 12 : if (obj2 == Py_None)
23406 6 : arg3 = NULL;
23407 : else {
23408 : PyObject *pypointer;
23409 6 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
23410 : &bytesio3, &view3);
23411 6 : if (pypointer == NULL)
23412 : return NULL;
23413 6 : have_view3 = !! view3.obj;
23414 :
23415 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
23416 :
23417 : /* Following code is from swig's python.swg. */
23418 :
23419 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
23420 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23421 0 : Py_DECREF(pypointer);
23422 : return NULL;
23423 : }
23424 6 : Py_DECREF(pypointer);
23425 : }
23426 : }
23427 : {
23428 : /* If we create a temporary wrapper4 object, we will store it in
23429 : wrapperN, where N is 4. Here in this fragment, SWIG will
23430 : automatically append 4. */
23431 12 : memset(&view4, 0, sizeof view4);
23432 12 : if (obj3 == Py_None)
23433 6 : arg4 = NULL;
23434 : else {
23435 : PyObject *pypointer;
23436 6 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
23437 : &bytesio4, &view4);
23438 6 : if (pypointer == NULL)
23439 : return NULL;
23440 6 : have_view4 = !! view4.obj;
23441 :
23442 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
23443 :
23444 : /* Following code is from swig's python.swg. */
23445 :
23446 6 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
23447 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
23448 0 : Py_DECREF(pypointer);
23449 : return NULL;
23450 : }
23451 6 : Py_DECREF(pypointer);
23452 : }
23453 : }
23454 : {
23455 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
23456 12 : result = gpgme_op_verify(arg1,arg2,arg3,arg4);
23457 12 : SWIG_PYTHON_THREAD_END_ALLOW;
23458 : }
23459 : {
23460 12 : resultobj = PyLong_FromLong(result);
23461 : }
23462 : {
23463 : /* See whether we need to update the Python buffer. */
23464 12 : if (resultobj && wrapper2 && view2.buf)
23465 : {
23466 : int dirty;
23467 6 : char *new_data = NULL;
23468 : size_t new_size;
23469 :
23470 :
23471 6 : new_data = wrapper2->data.mem.buffer;
23472 6 : new_size = wrapper2->data.mem.length;
23473 6 : dirty = new_data != NULL;
23474 :
23475 :
23476 :
23477 :
23478 :
23479 :
23480 :
23481 6 : if (dirty)
23482 : {
23483 : /* The buffer is dirty. */
23484 0 : if (view2.readonly)
23485 : {
23486 0 : Py_XDECREF(resultobj);
23487 0 : resultobj = NULL;
23488 0 : PyErr_SetString(PyExc_ValueError,
23489 : "cannot update read-only buffer");
23490 : }
23491 :
23492 : /* See if we need to truncate the buffer. */
23493 0 : if (resultobj && view2.len != new_size)
23494 : {
23495 0 : if (bytesio2 == NULL)
23496 : {
23497 0 : Py_XDECREF(resultobj);
23498 0 : resultobj = NULL;
23499 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23500 : }
23501 : else
23502 : {
23503 : PyObject *retval;
23504 0 : PyBuffer_Release(&view2);
23505 : assert(view2.obj == NULL);
23506 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
23507 : "l", (long) new_size);
23508 0 : if (retval == NULL)
23509 : {
23510 0 : Py_XDECREF(resultobj);
23511 : resultobj = NULL;
23512 : }
23513 : else
23514 : {
23515 0 : Py_DECREF(retval);
23516 :
23517 0 : retval = PyObject_CallMethod(bytesio2,
23518 : "getbuffer", NULL);
23519 0 : if (retval == NULL
23520 0 : || PyObject_GetBuffer(retval, &view2,
23521 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23522 : {
23523 0 : Py_XDECREF(resultobj);
23524 : resultobj = NULL;
23525 : }
23526 :
23527 0 : Py_XDECREF(retval);
23528 :
23529 0 : if (resultobj && view2.len
23530 : != new_size)
23531 : {
23532 0 : Py_XDECREF(resultobj);
23533 0 : resultobj = NULL;
23534 0 : PyErr_Format(PyExc_ValueError,
23535 : "Expected buffer of length %zu, got %zi",
23536 : new_size,
23537 : view2.len);
23538 : }
23539 : }
23540 : }
23541 : }
23542 0 : if (resultobj)
23543 0 : memcpy(view2.buf, new_data, new_size);
23544 : }
23545 :
23546 :
23547 :
23548 : }
23549 :
23550 : /* Free the temporary wrapper, if any. */
23551 12 : if (wrapper2)
23552 7 : gpgme_data_release(wrapper2);
23553 12 : Py_XDECREF (bytesio2);
23554 12 : if (have_view2 && view2.buf)
23555 6 : PyBuffer_Release(&view2);
23556 : }
23557 : {
23558 : /* See whether we need to update the Python buffer. */
23559 12 : if (resultobj && wrapper3 && view3.buf)
23560 : {
23561 : int dirty;
23562 4 : char *new_data = NULL;
23563 : size_t new_size;
23564 :
23565 :
23566 4 : new_data = wrapper3->data.mem.buffer;
23567 4 : new_size = wrapper3->data.mem.length;
23568 4 : dirty = new_data != NULL;
23569 :
23570 :
23571 :
23572 :
23573 :
23574 :
23575 :
23576 4 : if (dirty)
23577 : {
23578 : /* The buffer is dirty. */
23579 0 : if (view3.readonly)
23580 : {
23581 0 : Py_XDECREF(resultobj);
23582 0 : resultobj = NULL;
23583 0 : PyErr_SetString(PyExc_ValueError,
23584 : "cannot update read-only buffer");
23585 : }
23586 :
23587 : /* See if we need to truncate the buffer. */
23588 0 : if (resultobj && view3.len != new_size)
23589 : {
23590 0 : if (bytesio3 == NULL)
23591 : {
23592 0 : Py_XDECREF(resultobj);
23593 0 : resultobj = NULL;
23594 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23595 : }
23596 : else
23597 : {
23598 : PyObject *retval;
23599 0 : PyBuffer_Release(&view3);
23600 : assert(view3.obj == NULL);
23601 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
23602 : "l", (long) new_size);
23603 0 : if (retval == NULL)
23604 : {
23605 0 : Py_XDECREF(resultobj);
23606 : resultobj = NULL;
23607 : }
23608 : else
23609 : {
23610 0 : Py_DECREF(retval);
23611 :
23612 0 : retval = PyObject_CallMethod(bytesio3,
23613 : "getbuffer", NULL);
23614 0 : if (retval == NULL
23615 0 : || PyObject_GetBuffer(retval, &view3,
23616 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23617 : {
23618 0 : Py_XDECREF(resultobj);
23619 : resultobj = NULL;
23620 : }
23621 :
23622 0 : Py_XDECREF(retval);
23623 :
23624 0 : if (resultobj && view3.len
23625 : != new_size)
23626 : {
23627 0 : Py_XDECREF(resultobj);
23628 0 : resultobj = NULL;
23629 0 : PyErr_Format(PyExc_ValueError,
23630 : "Expected buffer of length %zu, got %zi",
23631 : new_size,
23632 : view3.len);
23633 : }
23634 : }
23635 : }
23636 : }
23637 0 : if (resultobj)
23638 0 : memcpy(view3.buf, new_data, new_size);
23639 : }
23640 :
23641 :
23642 :
23643 : }
23644 :
23645 : /* Free the temporary wrapper, if any. */
23646 12 : if (wrapper3)
23647 4 : gpgme_data_release(wrapper3);
23648 12 : Py_XDECREF (bytesio3);
23649 12 : if (have_view3 && view3.buf)
23650 4 : PyBuffer_Release(&view3);
23651 : }
23652 : {
23653 : /* See whether we need to update the Python buffer. */
23654 12 : if (resultobj && wrapper4 && view4.buf)
23655 : {
23656 : int dirty;
23657 0 : char *new_data = NULL;
23658 : size_t new_size;
23659 :
23660 :
23661 0 : new_data = wrapper4->data.mem.buffer;
23662 0 : new_size = wrapper4->data.mem.length;
23663 0 : dirty = new_data != NULL;
23664 :
23665 :
23666 :
23667 :
23668 :
23669 :
23670 :
23671 0 : if (dirty)
23672 : {
23673 : /* The buffer is dirty. */
23674 0 : if (view4.readonly)
23675 : {
23676 0 : Py_XDECREF(resultobj);
23677 0 : resultobj = NULL;
23678 0 : PyErr_SetString(PyExc_ValueError,
23679 : "cannot update read-only buffer");
23680 : }
23681 :
23682 : /* See if we need to truncate the buffer. */
23683 0 : if (resultobj && view4.len != new_size)
23684 : {
23685 0 : if (bytesio4 == NULL)
23686 : {
23687 0 : Py_XDECREF(resultobj);
23688 0 : resultobj = NULL;
23689 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23690 : }
23691 : else
23692 : {
23693 : PyObject *retval;
23694 0 : PyBuffer_Release(&view4);
23695 : assert(view4.obj == NULL);
23696 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
23697 : "l", (long) new_size);
23698 0 : if (retval == NULL)
23699 : {
23700 0 : Py_XDECREF(resultobj);
23701 : resultobj = NULL;
23702 : }
23703 : else
23704 : {
23705 0 : Py_DECREF(retval);
23706 :
23707 0 : retval = PyObject_CallMethod(bytesio4,
23708 : "getbuffer", NULL);
23709 0 : if (retval == NULL
23710 0 : || PyObject_GetBuffer(retval, &view4,
23711 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23712 : {
23713 0 : Py_XDECREF(resultobj);
23714 : resultobj = NULL;
23715 : }
23716 :
23717 0 : Py_XDECREF(retval);
23718 :
23719 0 : if (resultobj && view4.len
23720 : != new_size)
23721 : {
23722 0 : Py_XDECREF(resultobj);
23723 0 : resultobj = NULL;
23724 0 : PyErr_Format(PyExc_ValueError,
23725 : "Expected buffer of length %zu, got %zi",
23726 : new_size,
23727 : view4.len);
23728 : }
23729 : }
23730 : }
23731 : }
23732 0 : if (resultobj)
23733 0 : memcpy(view4.buf, new_data, new_size);
23734 : }
23735 :
23736 :
23737 :
23738 : }
23739 :
23740 : /* Free the temporary wrapper, if any. */
23741 12 : if (wrapper4)
23742 1 : gpgme_data_release(wrapper4);
23743 12 : Py_XDECREF (bytesio4);
23744 12 : if (have_view4 && view4.buf)
23745 0 : PyBuffer_Release(&view4);
23746 : }
23747 : return resultobj;
23748 : fail:
23749 : {
23750 : /* See whether we need to update the Python buffer. */
23751 : if (resultobj && wrapper2 && view2.buf)
23752 : {
23753 : int dirty;
23754 : char *new_data = NULL;
23755 : size_t new_size;
23756 :
23757 :
23758 : new_data = wrapper2->data.mem.buffer;
23759 : new_size = wrapper2->data.mem.length;
23760 : dirty = new_data != NULL;
23761 :
23762 :
23763 :
23764 :
23765 :
23766 :
23767 :
23768 : if (dirty)
23769 : {
23770 : /* The buffer is dirty. */
23771 : if (view2.readonly)
23772 : {
23773 : Py_XDECREF(resultobj);
23774 : resultobj = NULL;
23775 : PyErr_SetString(PyExc_ValueError,
23776 : "cannot update read-only buffer");
23777 : }
23778 :
23779 : /* See if we need to truncate the buffer. */
23780 : if (resultobj && view2.len != new_size)
23781 : {
23782 : if (bytesio2 == NULL)
23783 : {
23784 : Py_XDECREF(resultobj);
23785 : resultobj = NULL;
23786 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23787 : }
23788 : else
23789 : {
23790 : PyObject *retval;
23791 : PyBuffer_Release(&view2);
23792 : assert(view2.obj == NULL);
23793 : retval = PyObject_CallMethod(bytesio2, "truncate",
23794 : "l", (long) new_size);
23795 : if (retval == NULL)
23796 : {
23797 : Py_XDECREF(resultobj);
23798 : resultobj = NULL;
23799 : }
23800 : else
23801 : {
23802 : Py_DECREF(retval);
23803 :
23804 : retval = PyObject_CallMethod(bytesio2,
23805 : "getbuffer", NULL);
23806 : if (retval == NULL
23807 : || PyObject_GetBuffer(retval, &view2,
23808 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23809 : {
23810 : Py_XDECREF(resultobj);
23811 : resultobj = NULL;
23812 : }
23813 :
23814 : Py_XDECREF(retval);
23815 :
23816 : if (resultobj && view2.len
23817 : != new_size)
23818 : {
23819 : Py_XDECREF(resultobj);
23820 : resultobj = NULL;
23821 : PyErr_Format(PyExc_ValueError,
23822 : "Expected buffer of length %zu, got %zi",
23823 : new_size,
23824 : view2.len);
23825 : }
23826 : }
23827 : }
23828 : }
23829 : if (resultobj)
23830 : memcpy(view2.buf, new_data, new_size);
23831 : }
23832 :
23833 :
23834 :
23835 : }
23836 :
23837 : /* Free the temporary wrapper, if any. */
23838 0 : if (wrapper2)
23839 0 : gpgme_data_release(wrapper2);
23840 0 : Py_XDECREF (bytesio2);
23841 : if (have_view2 && view2.buf)
23842 : PyBuffer_Release(&view2);
23843 : }
23844 : {
23845 : /* See whether we need to update the Python buffer. */
23846 : if (resultobj && wrapper3 && view3.buf)
23847 : {
23848 : int dirty;
23849 : char *new_data = NULL;
23850 : size_t new_size;
23851 :
23852 :
23853 : new_data = wrapper3->data.mem.buffer;
23854 : new_size = wrapper3->data.mem.length;
23855 : dirty = new_data != NULL;
23856 :
23857 :
23858 :
23859 :
23860 :
23861 :
23862 :
23863 : if (dirty)
23864 : {
23865 : /* The buffer is dirty. */
23866 : if (view3.readonly)
23867 : {
23868 : Py_XDECREF(resultobj);
23869 : resultobj = NULL;
23870 : PyErr_SetString(PyExc_ValueError,
23871 : "cannot update read-only buffer");
23872 : }
23873 :
23874 : /* See if we need to truncate the buffer. */
23875 : if (resultobj && view3.len != new_size)
23876 : {
23877 : if (bytesio3 == NULL)
23878 : {
23879 : Py_XDECREF(resultobj);
23880 : resultobj = NULL;
23881 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23882 : }
23883 : else
23884 : {
23885 : PyObject *retval;
23886 : PyBuffer_Release(&view3);
23887 : assert(view3.obj == NULL);
23888 : retval = PyObject_CallMethod(bytesio3, "truncate",
23889 : "l", (long) new_size);
23890 : if (retval == NULL)
23891 : {
23892 : Py_XDECREF(resultobj);
23893 : resultobj = NULL;
23894 : }
23895 : else
23896 : {
23897 : Py_DECREF(retval);
23898 :
23899 : retval = PyObject_CallMethod(bytesio3,
23900 : "getbuffer", NULL);
23901 : if (retval == NULL
23902 : || PyObject_GetBuffer(retval, &view3,
23903 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23904 : {
23905 : Py_XDECREF(resultobj);
23906 : resultobj = NULL;
23907 : }
23908 :
23909 : Py_XDECREF(retval);
23910 :
23911 : if (resultobj && view3.len
23912 : != new_size)
23913 : {
23914 : Py_XDECREF(resultobj);
23915 : resultobj = NULL;
23916 : PyErr_Format(PyExc_ValueError,
23917 : "Expected buffer of length %zu, got %zi",
23918 : new_size,
23919 : view3.len);
23920 : }
23921 : }
23922 : }
23923 : }
23924 : if (resultobj)
23925 : memcpy(view3.buf, new_data, new_size);
23926 : }
23927 :
23928 :
23929 :
23930 : }
23931 :
23932 : /* Free the temporary wrapper, if any. */
23933 0 : if (wrapper3)
23934 0 : gpgme_data_release(wrapper3);
23935 0 : Py_XDECREF (bytesio3);
23936 : if (have_view3 && view3.buf)
23937 : PyBuffer_Release(&view3);
23938 : }
23939 : {
23940 : /* See whether we need to update the Python buffer. */
23941 : if (resultobj && wrapper4 && view4.buf)
23942 : {
23943 : int dirty;
23944 : char *new_data = NULL;
23945 : size_t new_size;
23946 :
23947 :
23948 : new_data = wrapper4->data.mem.buffer;
23949 : new_size = wrapper4->data.mem.length;
23950 : dirty = new_data != NULL;
23951 :
23952 :
23953 :
23954 :
23955 :
23956 :
23957 :
23958 : if (dirty)
23959 : {
23960 : /* The buffer is dirty. */
23961 : if (view4.readonly)
23962 : {
23963 : Py_XDECREF(resultobj);
23964 : resultobj = NULL;
23965 : PyErr_SetString(PyExc_ValueError,
23966 : "cannot update read-only buffer");
23967 : }
23968 :
23969 : /* See if we need to truncate the buffer. */
23970 : if (resultobj && view4.len != new_size)
23971 : {
23972 : if (bytesio4 == NULL)
23973 : {
23974 : Py_XDECREF(resultobj);
23975 : resultobj = NULL;
23976 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
23977 : }
23978 : else
23979 : {
23980 : PyObject *retval;
23981 : PyBuffer_Release(&view4);
23982 : assert(view4.obj == NULL);
23983 : retval = PyObject_CallMethod(bytesio4, "truncate",
23984 : "l", (long) new_size);
23985 : if (retval == NULL)
23986 : {
23987 : Py_XDECREF(resultobj);
23988 : resultobj = NULL;
23989 : }
23990 : else
23991 : {
23992 : Py_DECREF(retval);
23993 :
23994 : retval = PyObject_CallMethod(bytesio4,
23995 : "getbuffer", NULL);
23996 : if (retval == NULL
23997 : || PyObject_GetBuffer(retval, &view4,
23998 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
23999 : {
24000 : Py_XDECREF(resultobj);
24001 : resultobj = NULL;
24002 : }
24003 :
24004 : Py_XDECREF(retval);
24005 :
24006 : if (resultobj && view4.len
24007 : != new_size)
24008 : {
24009 : Py_XDECREF(resultobj);
24010 : resultobj = NULL;
24011 : PyErr_Format(PyExc_ValueError,
24012 : "Expected buffer of length %zu, got %zi",
24013 : new_size,
24014 : view4.len);
24015 : }
24016 : }
24017 : }
24018 : }
24019 : if (resultobj)
24020 : memcpy(view4.buf, new_data, new_size);
24021 : }
24022 :
24023 :
24024 :
24025 : }
24026 :
24027 : /* Free the temporary wrapper, if any. */
24028 0 : if (wrapper4)
24029 0 : gpgme_data_release(wrapper4);
24030 0 : Py_XDECREF (bytesio4);
24031 : if (have_view4 && view4.buf)
24032 : PyBuffer_Release(&view4);
24033 : }
24034 : return NULL;
24035 : }
24036 :
24037 :
24038 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24039 0 : PyObject *resultobj = 0;
24040 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24041 0 : char *arg2 = (char *) 0 ;
24042 0 : void *argp1 = 0 ;
24043 0 : int res1 = 0 ;
24044 : int res2 ;
24045 0 : char *buf2 = 0 ;
24046 0 : int alloc2 = 0 ;
24047 0 : PyObject * obj0 = 0 ;
24048 0 : PyObject * obj1 = 0 ;
24049 :
24050 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_fpr_set",&obj0,&obj1)) SWIG_fail;
24051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24052 0 : if (!SWIG_IsOK(res1)) {
24053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24054 : }
24055 0 : arg1 = (struct _gpgme_import_status *)(argp1);
24056 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
24057 0 : if (!SWIG_IsOK(res2)) {
24058 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_import_status_fpr_set" "', argument " "2"" of type '" "char *""'");
24059 : }
24060 0 : arg2 = (char *)(buf2);
24061 : {
24062 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24063 0 : if (arg1->fpr) free((char*)arg1->fpr);
24064 0 : if (arg2) {
24065 0 : size_t size = strlen((const char *)(arg2)) + 1;
24066 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
24067 : } else {
24068 0 : arg1->fpr = 0;
24069 : }
24070 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24071 : }
24072 0 : resultobj = SWIG_Py_Void();
24073 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24074 : return resultobj;
24075 : fail:
24076 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
24077 : return NULL;
24078 : }
24079 :
24080 :
24081 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24082 3 : PyObject *resultobj = 0;
24083 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24084 3 : void *argp1 = 0 ;
24085 3 : int res1 = 0 ;
24086 3 : PyObject * obj0 = 0 ;
24087 3 : char *result = 0 ;
24088 :
24089 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_fpr_get",&obj0)) SWIG_fail;
24090 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24091 3 : if (!SWIG_IsOK(res1)) {
24092 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_fpr_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24093 : }
24094 3 : arg1 = (struct _gpgme_import_status *)(argp1);
24095 : {
24096 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24097 3 : result = (char *) ((arg1)->fpr);
24098 3 : SWIG_PYTHON_THREAD_END_ALLOW;
24099 : }
24100 3 : resultobj = SWIG_FromCharPtr((const char *)result);
24101 3 : return resultobj;
24102 : fail:
24103 : return NULL;
24104 : }
24105 :
24106 :
24107 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24108 0 : PyObject *resultobj = 0;
24109 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24110 : gpgme_error_t arg2 ;
24111 0 : void *argp1 = 0 ;
24112 0 : int res1 = 0 ;
24113 0 : PyObject * obj0 = 0 ;
24114 0 : PyObject * obj1 = 0 ;
24115 :
24116 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_result_set",&obj0,&obj1)) SWIG_fail;
24117 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24118 0 : if (!SWIG_IsOK(res1)) {
24119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24120 : }
24121 0 : arg1 = (struct _gpgme_import_status *)(argp1);
24122 : {
24123 0 : if (PyLong_Check(obj1))
24124 0 : arg2 = PyLong_AsLong(obj1);
24125 :
24126 0 : else if (PyInt_Check(obj1))
24127 0 : arg2 = PyInt_AsLong(obj1);
24128 :
24129 : else
24130 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
24131 : }
24132 : {
24133 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24134 0 : if (arg1) (arg1)->result = arg2;
24135 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24136 : }
24137 0 : resultobj = SWIG_Py_Void();
24138 0 : return resultobj;
24139 : fail:
24140 : return NULL;
24141 : }
24142 :
24143 :
24144 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_result_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24145 3 : PyObject *resultobj = 0;
24146 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24147 3 : void *argp1 = 0 ;
24148 3 : int res1 = 0 ;
24149 3 : PyObject * obj0 = 0 ;
24150 : gpgme_error_t result;
24151 :
24152 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_result_get",&obj0)) SWIG_fail;
24153 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24154 3 : if (!SWIG_IsOK(res1)) {
24155 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_result_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24156 : }
24157 3 : arg1 = (struct _gpgme_import_status *)(argp1);
24158 : {
24159 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24160 3 : result = ((arg1)->result);
24161 3 : SWIG_PYTHON_THREAD_END_ALLOW;
24162 : }
24163 : {
24164 3 : resultobj = PyLong_FromLong(result);
24165 : }
24166 3 : return resultobj;
24167 : fail:
24168 : return NULL;
24169 : }
24170 :
24171 :
24172 0 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 0 : PyObject *resultobj = 0;
24174 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24175 : unsigned int arg2 ;
24176 0 : void *argp1 = 0 ;
24177 0 : int res1 = 0 ;
24178 : unsigned int val2 ;
24179 0 : int ecode2 = 0 ;
24180 0 : PyObject * obj0 = 0 ;
24181 0 : PyObject * obj1 = 0 ;
24182 :
24183 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_import_status_status_set",&obj0,&obj1)) SWIG_fail;
24184 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24185 0 : if (!SWIG_IsOK(res1)) {
24186 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_set" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24187 : }
24188 0 : arg1 = (struct _gpgme_import_status *)(argp1);
24189 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
24190 0 : if (!SWIG_IsOK(ecode2)) {
24191 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_import_status_status_set" "', argument " "2"" of type '" "unsigned int""'");
24192 : }
24193 0 : arg2 = (unsigned int)(val2);
24194 : {
24195 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24196 0 : if (arg1) (arg1)->status = arg2;
24197 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24198 : }
24199 0 : resultobj = SWIG_Py_Void();
24200 0 : return resultobj;
24201 : fail:
24202 : return NULL;
24203 : }
24204 :
24205 :
24206 3 : SWIGINTERN PyObject *_wrap__gpgme_import_status_status_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24207 3 : PyObject *resultobj = 0;
24208 3 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24209 3 : void *argp1 = 0 ;
24210 3 : int res1 = 0 ;
24211 3 : PyObject * obj0 = 0 ;
24212 : unsigned int result;
24213 :
24214 3 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_import_status_status_get",&obj0)) SWIG_fail;
24215 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, 0 | 0 );
24216 3 : if (!SWIG_IsOK(res1)) {
24217 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_import_status_status_get" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24218 : }
24219 3 : arg1 = (struct _gpgme_import_status *)(argp1);
24220 : {
24221 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24222 3 : result = (unsigned int) ((arg1)->status);
24223 3 : SWIG_PYTHON_THREAD_END_ALLOW;
24224 : }
24225 3 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
24226 3 : return resultobj;
24227 : fail:
24228 : return NULL;
24229 : }
24230 :
24231 :
24232 0 : SWIGINTERN PyObject *_wrap_new__gpgme_import_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24233 0 : PyObject *resultobj = 0;
24234 0 : struct _gpgme_import_status *result = 0 ;
24235 :
24236 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_import_status")) SWIG_fail;
24237 : {
24238 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24239 0 : result = (struct _gpgme_import_status *)calloc(1, sizeof(struct _gpgme_import_status));
24240 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24241 : }
24242 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_NEW | 0 );
24243 0 : return resultobj;
24244 : fail:
24245 : return NULL;
24246 : }
24247 :
24248 :
24249 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_import_status(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24250 0 : PyObject *resultobj = 0;
24251 0 : struct _gpgme_import_status *arg1 = (struct _gpgme_import_status *) 0 ;
24252 0 : void *argp1 = 0 ;
24253 0 : int res1 = 0 ;
24254 0 : PyObject * obj0 = 0 ;
24255 :
24256 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_import_status",&obj0)) SWIG_fail;
24257 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
24258 0 : if (!SWIG_IsOK(res1)) {
24259 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_import_status" "', argument " "1"" of type '" "struct _gpgme_import_status *""'");
24260 : }
24261 0 : arg1 = (struct _gpgme_import_status *)(argp1);
24262 : {
24263 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24264 0 : free((char *) arg1);
24265 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24266 : }
24267 0 : resultobj = SWIG_Py_Void();
24268 0 : return resultobj;
24269 : fail:
24270 : return NULL;
24271 : }
24272 :
24273 :
24274 27 : SWIGINTERN PyObject *_gpgme_import_status_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24275 : PyObject *obj;
24276 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
24277 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_import_status, SWIG_NewClientData(obj));
24278 27 : return SWIG_Py_Void();
24279 : }
24280 :
24281 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24282 0 : PyObject *resultobj = 0;
24283 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24284 : int arg2 ;
24285 0 : void *argp1 = 0 ;
24286 0 : int res1 = 0 ;
24287 : int val2 ;
24288 0 : int ecode2 = 0 ;
24289 0 : PyObject * obj0 = 0 ;
24290 0 : PyObject * obj1 = 0 ;
24291 :
24292 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_considered_set",&obj0,&obj1)) SWIG_fail;
24293 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24294 0 : if (!SWIG_IsOK(res1)) {
24295 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24296 : }
24297 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24298 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24299 0 : if (!SWIG_IsOK(ecode2)) {
24300 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_considered_set" "', argument " "2"" of type '" "int""'");
24301 : }
24302 0 : arg2 = (int)(val2);
24303 : {
24304 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24305 0 : if (arg1) (arg1)->considered = arg2;
24306 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24307 : }
24308 0 : resultobj = SWIG_Py_Void();
24309 0 : return resultobj;
24310 : fail:
24311 : return NULL;
24312 : }
24313 :
24314 :
24315 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_considered_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24316 2 : PyObject *resultobj = 0;
24317 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24318 2 : void *argp1 = 0 ;
24319 2 : int res1 = 0 ;
24320 2 : PyObject * obj0 = 0 ;
24321 : int result;
24322 :
24323 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_considered_get",&obj0)) SWIG_fail;
24324 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24325 2 : if (!SWIG_IsOK(res1)) {
24326 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_considered_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24327 : }
24328 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24329 : {
24330 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24331 2 : result = (int) ((arg1)->considered);
24332 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24333 : }
24334 2 : resultobj = SWIG_From_int((int)(result));
24335 2 : return resultobj;
24336 : fail:
24337 : return NULL;
24338 : }
24339 :
24340 :
24341 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24342 0 : PyObject *resultobj = 0;
24343 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24344 : int arg2 ;
24345 0 : void *argp1 = 0 ;
24346 0 : int res1 = 0 ;
24347 : int val2 ;
24348 0 : int ecode2 = 0 ;
24349 0 : PyObject * obj0 = 0 ;
24350 0 : PyObject * obj1 = 0 ;
24351 :
24352 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_no_user_id_set",&obj0,&obj1)) SWIG_fail;
24353 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24354 0 : if (!SWIG_IsOK(res1)) {
24355 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_no_user_id_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24356 : }
24357 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24358 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24359 0 : if (!SWIG_IsOK(ecode2)) {
24360 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_no_user_id_set" "', argument " "2"" of type '" "int""'");
24361 : }
24362 0 : arg2 = (int)(val2);
24363 : {
24364 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24365 0 : if (arg1) (arg1)->no_user_id = arg2;
24366 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24367 : }
24368 0 : resultobj = SWIG_Py_Void();
24369 0 : return resultobj;
24370 : fail:
24371 : return NULL;
24372 : }
24373 :
24374 :
24375 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_no_user_id_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24376 2 : PyObject *resultobj = 0;
24377 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24378 2 : void *argp1 = 0 ;
24379 2 : int res1 = 0 ;
24380 2 : PyObject * obj0 = 0 ;
24381 : int result;
24382 :
24383 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_no_user_id_get",&obj0)) SWIG_fail;
24384 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24385 2 : if (!SWIG_IsOK(res1)) {
24386 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_no_user_id_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24387 : }
24388 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24389 : {
24390 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24391 2 : result = (int) ((arg1)->no_user_id);
24392 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24393 : }
24394 2 : resultobj = SWIG_From_int((int)(result));
24395 2 : return resultobj;
24396 : fail:
24397 : return NULL;
24398 : }
24399 :
24400 :
24401 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24402 0 : PyObject *resultobj = 0;
24403 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24404 : int arg2 ;
24405 0 : void *argp1 = 0 ;
24406 0 : int res1 = 0 ;
24407 : int val2 ;
24408 0 : int ecode2 = 0 ;
24409 0 : PyObject * obj0 = 0 ;
24410 0 : PyObject * obj1 = 0 ;
24411 :
24412 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imported_set",&obj0,&obj1)) SWIG_fail;
24413 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24414 0 : if (!SWIG_IsOK(res1)) {
24415 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24416 : }
24417 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24418 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24419 0 : if (!SWIG_IsOK(ecode2)) {
24420 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_set" "', argument " "2"" of type '" "int""'");
24421 : }
24422 0 : arg2 = (int)(val2);
24423 : {
24424 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24425 0 : if (arg1) (arg1)->imported = arg2;
24426 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24427 : }
24428 0 : resultobj = SWIG_Py_Void();
24429 0 : return resultobj;
24430 : fail:
24431 : return NULL;
24432 : }
24433 :
24434 :
24435 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24436 2 : PyObject *resultobj = 0;
24437 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24438 2 : void *argp1 = 0 ;
24439 2 : int res1 = 0 ;
24440 2 : PyObject * obj0 = 0 ;
24441 : int result;
24442 :
24443 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_get",&obj0)) SWIG_fail;
24444 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24445 2 : if (!SWIG_IsOK(res1)) {
24446 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24447 : }
24448 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24449 : {
24450 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24451 2 : result = (int) ((arg1)->imported);
24452 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24453 : }
24454 2 : resultobj = SWIG_From_int((int)(result));
24455 2 : return resultobj;
24456 : fail:
24457 : return NULL;
24458 : }
24459 :
24460 :
24461 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24462 0 : PyObject *resultobj = 0;
24463 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24464 : int arg2 ;
24465 0 : void *argp1 = 0 ;
24466 0 : int res1 = 0 ;
24467 : int val2 ;
24468 0 : int ecode2 = 0 ;
24469 0 : PyObject * obj0 = 0 ;
24470 0 : PyObject * obj1 = 0 ;
24471 :
24472 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imported_rsa_set",&obj0,&obj1)) SWIG_fail;
24473 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24474 0 : if (!SWIG_IsOK(res1)) {
24475 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_rsa_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24476 : }
24477 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24478 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24479 0 : if (!SWIG_IsOK(ecode2)) {
24480 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_imported_rsa_set" "', argument " "2"" of type '" "int""'");
24481 : }
24482 0 : arg2 = (int)(val2);
24483 : {
24484 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24485 0 : if (arg1) (arg1)->imported_rsa = arg2;
24486 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24487 : }
24488 0 : resultobj = SWIG_Py_Void();
24489 0 : return resultobj;
24490 : fail:
24491 : return NULL;
24492 : }
24493 :
24494 :
24495 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imported_rsa_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24496 2 : PyObject *resultobj = 0;
24497 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24498 2 : void *argp1 = 0 ;
24499 2 : int res1 = 0 ;
24500 2 : PyObject * obj0 = 0 ;
24501 : int result;
24502 :
24503 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imported_rsa_get",&obj0)) SWIG_fail;
24504 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24505 2 : if (!SWIG_IsOK(res1)) {
24506 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imported_rsa_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24507 : }
24508 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24509 : {
24510 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24511 2 : result = (int) ((arg1)->imported_rsa);
24512 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24513 : }
24514 2 : resultobj = SWIG_From_int((int)(result));
24515 2 : return resultobj;
24516 : fail:
24517 : return NULL;
24518 : }
24519 :
24520 :
24521 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24522 0 : PyObject *resultobj = 0;
24523 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24524 : int arg2 ;
24525 0 : void *argp1 = 0 ;
24526 0 : int res1 = 0 ;
24527 : int val2 ;
24528 0 : int ecode2 = 0 ;
24529 0 : PyObject * obj0 = 0 ;
24530 0 : PyObject * obj1 = 0 ;
24531 :
24532 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_unchanged_set",&obj0,&obj1)) SWIG_fail;
24533 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24534 0 : if (!SWIG_IsOK(res1)) {
24535 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24536 : }
24537 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24538 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24539 0 : if (!SWIG_IsOK(ecode2)) {
24540 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_unchanged_set" "', argument " "2"" of type '" "int""'");
24541 : }
24542 0 : arg2 = (int)(val2);
24543 : {
24544 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24545 0 : if (arg1) (arg1)->unchanged = arg2;
24546 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24547 : }
24548 0 : resultobj = SWIG_Py_Void();
24549 0 : return resultobj;
24550 : fail:
24551 : return NULL;
24552 : }
24553 :
24554 :
24555 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_unchanged_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24556 2 : PyObject *resultobj = 0;
24557 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24558 2 : void *argp1 = 0 ;
24559 2 : int res1 = 0 ;
24560 2 : PyObject * obj0 = 0 ;
24561 : int result;
24562 :
24563 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_unchanged_get",&obj0)) SWIG_fail;
24564 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24565 2 : if (!SWIG_IsOK(res1)) {
24566 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_unchanged_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24567 : }
24568 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24569 : {
24570 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24571 2 : result = (int) ((arg1)->unchanged);
24572 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24573 : }
24574 2 : resultobj = SWIG_From_int((int)(result));
24575 2 : return resultobj;
24576 : fail:
24577 : return NULL;
24578 : }
24579 :
24580 :
24581 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24582 0 : PyObject *resultobj = 0;
24583 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24584 : int arg2 ;
24585 0 : void *argp1 = 0 ;
24586 0 : int res1 = 0 ;
24587 : int val2 ;
24588 0 : int ecode2 = 0 ;
24589 0 : PyObject * obj0 = 0 ;
24590 0 : PyObject * obj1 = 0 ;
24591 :
24592 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_user_ids_set",&obj0,&obj1)) SWIG_fail;
24593 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24594 0 : if (!SWIG_IsOK(res1)) {
24595 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_user_ids_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24596 : }
24597 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24598 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24599 0 : if (!SWIG_IsOK(ecode2)) {
24600 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_user_ids_set" "', argument " "2"" of type '" "int""'");
24601 : }
24602 0 : arg2 = (int)(val2);
24603 : {
24604 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24605 0 : if (arg1) (arg1)->new_user_ids = arg2;
24606 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24607 : }
24608 0 : resultobj = SWIG_Py_Void();
24609 0 : return resultobj;
24610 : fail:
24611 : return NULL;
24612 : }
24613 :
24614 :
24615 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_user_ids_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24616 2 : PyObject *resultobj = 0;
24617 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24618 2 : void *argp1 = 0 ;
24619 2 : int res1 = 0 ;
24620 2 : PyObject * obj0 = 0 ;
24621 : int result;
24622 :
24623 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_user_ids_get",&obj0)) SWIG_fail;
24624 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24625 2 : if (!SWIG_IsOK(res1)) {
24626 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_user_ids_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24627 : }
24628 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24629 : {
24630 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24631 2 : result = (int) ((arg1)->new_user_ids);
24632 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24633 : }
24634 2 : resultobj = SWIG_From_int((int)(result));
24635 2 : return resultobj;
24636 : fail:
24637 : return NULL;
24638 : }
24639 :
24640 :
24641 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24642 0 : PyObject *resultobj = 0;
24643 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24644 : int arg2 ;
24645 0 : void *argp1 = 0 ;
24646 0 : int res1 = 0 ;
24647 : int val2 ;
24648 0 : int ecode2 = 0 ;
24649 0 : PyObject * obj0 = 0 ;
24650 0 : PyObject * obj1 = 0 ;
24651 :
24652 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_sub_keys_set",&obj0,&obj1)) SWIG_fail;
24653 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24654 0 : if (!SWIG_IsOK(res1)) {
24655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_sub_keys_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24656 : }
24657 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24658 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24659 0 : if (!SWIG_IsOK(ecode2)) {
24660 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_sub_keys_set" "', argument " "2"" of type '" "int""'");
24661 : }
24662 0 : arg2 = (int)(val2);
24663 : {
24664 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24665 0 : if (arg1) (arg1)->new_sub_keys = arg2;
24666 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24667 : }
24668 0 : resultobj = SWIG_Py_Void();
24669 0 : return resultobj;
24670 : fail:
24671 : return NULL;
24672 : }
24673 :
24674 :
24675 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_sub_keys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24676 2 : PyObject *resultobj = 0;
24677 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24678 2 : void *argp1 = 0 ;
24679 2 : int res1 = 0 ;
24680 2 : PyObject * obj0 = 0 ;
24681 : int result;
24682 :
24683 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_sub_keys_get",&obj0)) SWIG_fail;
24684 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24685 2 : if (!SWIG_IsOK(res1)) {
24686 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_sub_keys_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24687 : }
24688 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24689 : {
24690 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24691 2 : result = (int) ((arg1)->new_sub_keys);
24692 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24693 : }
24694 2 : resultobj = SWIG_From_int((int)(result));
24695 2 : return resultobj;
24696 : fail:
24697 : return NULL;
24698 : }
24699 :
24700 :
24701 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24702 0 : PyObject *resultobj = 0;
24703 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24704 : int arg2 ;
24705 0 : void *argp1 = 0 ;
24706 0 : int res1 = 0 ;
24707 : int val2 ;
24708 0 : int ecode2 = 0 ;
24709 0 : PyObject * obj0 = 0 ;
24710 0 : PyObject * obj1 = 0 ;
24711 :
24712 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_signatures_set",&obj0,&obj1)) SWIG_fail;
24713 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24714 0 : if (!SWIG_IsOK(res1)) {
24715 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_signatures_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24716 : }
24717 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24718 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24719 0 : if (!SWIG_IsOK(ecode2)) {
24720 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_signatures_set" "', argument " "2"" of type '" "int""'");
24721 : }
24722 0 : arg2 = (int)(val2);
24723 : {
24724 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24725 0 : if (arg1) (arg1)->new_signatures = arg2;
24726 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24727 : }
24728 0 : resultobj = SWIG_Py_Void();
24729 0 : return resultobj;
24730 : fail:
24731 : return NULL;
24732 : }
24733 :
24734 :
24735 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_signatures_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24736 2 : PyObject *resultobj = 0;
24737 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24738 2 : void *argp1 = 0 ;
24739 2 : int res1 = 0 ;
24740 2 : PyObject * obj0 = 0 ;
24741 : int result;
24742 :
24743 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_signatures_get",&obj0)) SWIG_fail;
24744 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24745 2 : if (!SWIG_IsOK(res1)) {
24746 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_signatures_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24747 : }
24748 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24749 : {
24750 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24751 2 : result = (int) ((arg1)->new_signatures);
24752 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24753 : }
24754 2 : resultobj = SWIG_From_int((int)(result));
24755 2 : return resultobj;
24756 : fail:
24757 : return NULL;
24758 : }
24759 :
24760 :
24761 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24762 0 : PyObject *resultobj = 0;
24763 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24764 : int arg2 ;
24765 0 : void *argp1 = 0 ;
24766 0 : int res1 = 0 ;
24767 : int val2 ;
24768 0 : int ecode2 = 0 ;
24769 0 : PyObject * obj0 = 0 ;
24770 0 : PyObject * obj1 = 0 ;
24771 :
24772 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_new_revocations_set",&obj0,&obj1)) SWIG_fail;
24773 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24774 0 : if (!SWIG_IsOK(res1)) {
24775 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_revocations_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24776 : }
24777 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24778 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24779 0 : if (!SWIG_IsOK(ecode2)) {
24780 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_new_revocations_set" "', argument " "2"" of type '" "int""'");
24781 : }
24782 0 : arg2 = (int)(val2);
24783 : {
24784 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24785 0 : if (arg1) (arg1)->new_revocations = arg2;
24786 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24787 : }
24788 0 : resultobj = SWIG_Py_Void();
24789 0 : return resultobj;
24790 : fail:
24791 : return NULL;
24792 : }
24793 :
24794 :
24795 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_new_revocations_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24796 2 : PyObject *resultobj = 0;
24797 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24798 2 : void *argp1 = 0 ;
24799 2 : int res1 = 0 ;
24800 2 : PyObject * obj0 = 0 ;
24801 : int result;
24802 :
24803 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_new_revocations_get",&obj0)) SWIG_fail;
24804 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24805 2 : if (!SWIG_IsOK(res1)) {
24806 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_new_revocations_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24807 : }
24808 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24809 : {
24810 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24811 2 : result = (int) ((arg1)->new_revocations);
24812 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24813 : }
24814 2 : resultobj = SWIG_From_int((int)(result));
24815 2 : return resultobj;
24816 : fail:
24817 : return NULL;
24818 : }
24819 :
24820 :
24821 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24822 0 : PyObject *resultobj = 0;
24823 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24824 : int arg2 ;
24825 0 : void *argp1 = 0 ;
24826 0 : int res1 = 0 ;
24827 : int val2 ;
24828 0 : int ecode2 = 0 ;
24829 0 : PyObject * obj0 = 0 ;
24830 0 : PyObject * obj1 = 0 ;
24831 :
24832 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_read_set",&obj0,&obj1)) SWIG_fail;
24833 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24834 0 : if (!SWIG_IsOK(res1)) {
24835 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_read_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24836 : }
24837 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24838 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24839 0 : if (!SWIG_IsOK(ecode2)) {
24840 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_read_set" "', argument " "2"" of type '" "int""'");
24841 : }
24842 0 : arg2 = (int)(val2);
24843 : {
24844 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24845 0 : if (arg1) (arg1)->secret_read = arg2;
24846 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24847 : }
24848 0 : resultobj = SWIG_Py_Void();
24849 0 : return resultobj;
24850 : fail:
24851 : return NULL;
24852 : }
24853 :
24854 :
24855 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_read_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24856 2 : PyObject *resultobj = 0;
24857 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24858 2 : void *argp1 = 0 ;
24859 2 : int res1 = 0 ;
24860 2 : PyObject * obj0 = 0 ;
24861 : int result;
24862 :
24863 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_read_get",&obj0)) SWIG_fail;
24864 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24865 2 : if (!SWIG_IsOK(res1)) {
24866 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_read_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24867 : }
24868 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24869 : {
24870 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24871 2 : result = (int) ((arg1)->secret_read);
24872 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24873 : }
24874 2 : resultobj = SWIG_From_int((int)(result));
24875 2 : return resultobj;
24876 : fail:
24877 : return NULL;
24878 : }
24879 :
24880 :
24881 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24882 0 : PyObject *resultobj = 0;
24883 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24884 : int arg2 ;
24885 0 : void *argp1 = 0 ;
24886 0 : int res1 = 0 ;
24887 : int val2 ;
24888 0 : int ecode2 = 0 ;
24889 0 : PyObject * obj0 = 0 ;
24890 0 : PyObject * obj1 = 0 ;
24891 :
24892 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_imported_set",&obj0,&obj1)) SWIG_fail;
24893 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24894 0 : if (!SWIG_IsOK(res1)) {
24895 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24896 : }
24897 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24898 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24899 0 : if (!SWIG_IsOK(ecode2)) {
24900 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_imported_set" "', argument " "2"" of type '" "int""'");
24901 : }
24902 0 : arg2 = (int)(val2);
24903 : {
24904 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24905 0 : if (arg1) (arg1)->secret_imported = arg2;
24906 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24907 : }
24908 0 : resultobj = SWIG_Py_Void();
24909 0 : return resultobj;
24910 : fail:
24911 : return NULL;
24912 : }
24913 :
24914 :
24915 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24916 2 : PyObject *resultobj = 0;
24917 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24918 2 : void *argp1 = 0 ;
24919 2 : int res1 = 0 ;
24920 2 : PyObject * obj0 = 0 ;
24921 : int result;
24922 :
24923 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_imported_get",&obj0)) SWIG_fail;
24924 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24925 2 : if (!SWIG_IsOK(res1)) {
24926 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24927 : }
24928 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24929 : {
24930 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24931 2 : result = (int) ((arg1)->secret_imported);
24932 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24933 : }
24934 2 : resultobj = SWIG_From_int((int)(result));
24935 2 : return resultobj;
24936 : fail:
24937 : return NULL;
24938 : }
24939 :
24940 :
24941 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24942 0 : PyObject *resultobj = 0;
24943 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24944 : int arg2 ;
24945 0 : void *argp1 = 0 ;
24946 0 : int res1 = 0 ;
24947 : int val2 ;
24948 0 : int ecode2 = 0 ;
24949 0 : PyObject * obj0 = 0 ;
24950 0 : PyObject * obj1 = 0 ;
24951 :
24952 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_secret_unchanged_set",&obj0,&obj1)) SWIG_fail;
24953 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24954 0 : if (!SWIG_IsOK(res1)) {
24955 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_unchanged_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24956 : }
24957 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24958 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
24959 0 : if (!SWIG_IsOK(ecode2)) {
24960 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_secret_unchanged_set" "', argument " "2"" of type '" "int""'");
24961 : }
24962 0 : arg2 = (int)(val2);
24963 : {
24964 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24965 0 : if (arg1) (arg1)->secret_unchanged = arg2;
24966 0 : SWIG_PYTHON_THREAD_END_ALLOW;
24967 : }
24968 0 : resultobj = SWIG_Py_Void();
24969 0 : return resultobj;
24970 : fail:
24971 : return NULL;
24972 : }
24973 :
24974 :
24975 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_secret_unchanged_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24976 2 : PyObject *resultobj = 0;
24977 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
24978 2 : void *argp1 = 0 ;
24979 2 : int res1 = 0 ;
24980 2 : PyObject * obj0 = 0 ;
24981 : int result;
24982 :
24983 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_secret_unchanged_get",&obj0)) SWIG_fail;
24984 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
24985 2 : if (!SWIG_IsOK(res1)) {
24986 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_secret_unchanged_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
24987 : }
24988 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
24989 : {
24990 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
24991 2 : result = (int) ((arg1)->secret_unchanged);
24992 2 : SWIG_PYTHON_THREAD_END_ALLOW;
24993 : }
24994 2 : resultobj = SWIG_From_int((int)(result));
24995 2 : return resultobj;
24996 : fail:
24997 : return NULL;
24998 : }
24999 :
25000 :
25001 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25002 0 : PyObject *resultobj = 0;
25003 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25004 : int arg2 ;
25005 0 : void *argp1 = 0 ;
25006 0 : int res1 = 0 ;
25007 : int val2 ;
25008 0 : int ecode2 = 0 ;
25009 0 : PyObject * obj0 = 0 ;
25010 0 : PyObject * obj1 = 0 ;
25011 :
25012 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_skipped_new_keys_set",&obj0,&obj1)) SWIG_fail;
25013 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25014 0 : if (!SWIG_IsOK(res1)) {
25015 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_new_keys_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25016 : }
25017 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25018 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25019 0 : if (!SWIG_IsOK(ecode2)) {
25020 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_skipped_new_keys_set" "', argument " "2"" of type '" "int""'");
25021 : }
25022 0 : arg2 = (int)(val2);
25023 : {
25024 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25025 0 : if (arg1) (arg1)->skipped_new_keys = arg2;
25026 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25027 : }
25028 0 : resultobj = SWIG_Py_Void();
25029 0 : return resultobj;
25030 : fail:
25031 : return NULL;
25032 : }
25033 :
25034 :
25035 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_skipped_new_keys_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25036 2 : PyObject *resultobj = 0;
25037 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25038 2 : void *argp1 = 0 ;
25039 2 : int res1 = 0 ;
25040 2 : PyObject * obj0 = 0 ;
25041 : int result;
25042 :
25043 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_skipped_new_keys_get",&obj0)) SWIG_fail;
25044 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25045 2 : if (!SWIG_IsOK(res1)) {
25046 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_skipped_new_keys_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25047 : }
25048 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25049 : {
25050 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25051 2 : result = (int) ((arg1)->skipped_new_keys);
25052 2 : SWIG_PYTHON_THREAD_END_ALLOW;
25053 : }
25054 2 : resultobj = SWIG_From_int((int)(result));
25055 2 : return resultobj;
25056 : fail:
25057 : return NULL;
25058 : }
25059 :
25060 :
25061 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25062 0 : PyObject *resultobj = 0;
25063 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25064 : int arg2 ;
25065 0 : void *argp1 = 0 ;
25066 0 : int res1 = 0 ;
25067 : int val2 ;
25068 0 : int ecode2 = 0 ;
25069 0 : PyObject * obj0 = 0 ;
25070 0 : PyObject * obj1 = 0 ;
25071 :
25072 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_not_imported_set",&obj0,&obj1)) SWIG_fail;
25073 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25074 0 : if (!SWIG_IsOK(res1)) {
25075 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_not_imported_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25076 : }
25077 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25078 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
25079 0 : if (!SWIG_IsOK(ecode2)) {
25080 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_import_result_not_imported_set" "', argument " "2"" of type '" "int""'");
25081 : }
25082 0 : arg2 = (int)(val2);
25083 : {
25084 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25085 0 : if (arg1) (arg1)->not_imported = arg2;
25086 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25087 : }
25088 0 : resultobj = SWIG_Py_Void();
25089 0 : return resultobj;
25090 : fail:
25091 : return NULL;
25092 : }
25093 :
25094 :
25095 2 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_not_imported_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25096 2 : PyObject *resultobj = 0;
25097 2 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25098 2 : void *argp1 = 0 ;
25099 2 : int res1 = 0 ;
25100 2 : PyObject * obj0 = 0 ;
25101 : int result;
25102 :
25103 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_not_imported_get",&obj0)) SWIG_fail;
25104 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25105 2 : if (!SWIG_IsOK(res1)) {
25106 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_not_imported_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25107 : }
25108 2 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25109 : {
25110 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25111 2 : result = (int) ((arg1)->not_imported);
25112 2 : SWIG_PYTHON_THREAD_END_ALLOW;
25113 : }
25114 2 : resultobj = SWIG_From_int((int)(result));
25115 2 : return resultobj;
25116 : fail:
25117 : return NULL;
25118 : }
25119 :
25120 :
25121 0 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25122 0 : PyObject *resultobj = 0;
25123 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25124 0 : gpgme_import_status_t arg2 = (gpgme_import_status_t) 0 ;
25125 0 : void *argp1 = 0 ;
25126 0 : int res1 = 0 ;
25127 0 : void *argp2 = 0 ;
25128 0 : int res2 = 0 ;
25129 0 : PyObject * obj0 = 0 ;
25130 0 : PyObject * obj1 = 0 ;
25131 :
25132 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_import_result_imports_set",&obj0,&obj1)) SWIG_fail;
25133 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25134 0 : if (!SWIG_IsOK(res1)) {
25135 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25136 : }
25137 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25138 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_import_status, SWIG_POINTER_DISOWN | 0 );
25139 0 : if (!SWIG_IsOK(res2)) {
25140 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_import_result_imports_set" "', argument " "2"" of type '" "gpgme_import_status_t""'");
25141 : }
25142 0 : arg2 = (gpgme_import_status_t)(argp2);
25143 : {
25144 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25145 0 : if (arg1) (arg1)->imports = arg2;
25146 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25147 : }
25148 0 : resultobj = SWIG_Py_Void();
25149 0 : return resultobj;
25150 : fail:
25151 : return NULL;
25152 : }
25153 :
25154 :
25155 4 : SWIGINTERN PyObject *_wrap__gpgme_op_import_result_imports_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25156 4 : PyObject *resultobj = 0;
25157 4 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25158 4 : void *argp1 = 0 ;
25159 4 : int res1 = 0 ;
25160 4 : PyObject * obj0 = 0 ;
25161 : gpgme_import_status_t result;
25162 :
25163 4 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_import_result_imports_get",&obj0)) SWIG_fail;
25164 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, 0 | 0 );
25165 4 : if (!SWIG_IsOK(res1)) {
25166 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_import_result_imports_get" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25167 : }
25168 4 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25169 : {
25170 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25171 4 : result = (gpgme_import_status_t) ((arg1)->imports);
25172 4 : SWIG_PYTHON_THREAD_END_ALLOW;
25173 : }
25174 : {
25175 : int i;
25176 4 : int size = 0;
25177 : gpgme_import_status_t curr;
25178 10 : for (curr = result; curr != NULL; curr = curr->next) {
25179 6 : size++;
25180 : }
25181 4 : resultobj = PyList_New(size);
25182 10 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
25183 6 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_import_status, 0 );
25184 6 : PyList_SetItem(resultobj, i, o);
25185 : }
25186 : }
25187 : return resultobj;
25188 : fail:
25189 : return NULL;
25190 : }
25191 :
25192 :
25193 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25194 0 : PyObject *resultobj = 0;
25195 0 : struct _gpgme_op_import_result *result = 0 ;
25196 :
25197 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_import_result")) SWIG_fail;
25198 : {
25199 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25200 0 : result = (struct _gpgme_op_import_result *)calloc(1, sizeof(struct _gpgme_op_import_result));
25201 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25202 : }
25203 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result, SWIG_POINTER_NEW | 0 );
25204 0 : return resultobj;
25205 : fail:
25206 : return NULL;
25207 : }
25208 :
25209 :
25210 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25211 0 : PyObject *resultobj = 0;
25212 0 : struct _gpgme_op_import_result *arg1 = (struct _gpgme_op_import_result *) 0 ;
25213 0 : void *argp1 = 0 ;
25214 0 : int res1 = 0 ;
25215 0 : PyObject * obj0 = 0 ;
25216 :
25217 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_import_result",&obj0)) SWIG_fail;
25218 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_import_result, SWIG_POINTER_DISOWN | 0 );
25219 0 : if (!SWIG_IsOK(res1)) {
25220 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_import_result" "', argument " "1"" of type '" "struct _gpgme_op_import_result *""'");
25221 : }
25222 0 : arg1 = (struct _gpgme_op_import_result *)(argp1);
25223 : {
25224 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25225 0 : free((char *) arg1);
25226 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25227 : }
25228 0 : resultobj = SWIG_Py_Void();
25229 0 : return resultobj;
25230 : fail:
25231 : return NULL;
25232 : }
25233 :
25234 :
25235 27 : SWIGINTERN PyObject *_gpgme_op_import_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25236 : PyObject *obj;
25237 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
25238 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_import_result, SWIG_NewClientData(obj));
25239 27 : return SWIG_Py_Void();
25240 : }
25241 :
25242 2 : SWIGINTERN PyObject *_wrap_gpgme_op_import_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25243 2 : PyObject *resultobj = 0;
25244 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25245 2 : void *argp1 = 0 ;
25246 2 : int res1 = 0 ;
25247 2 : PyObject * obj0 = 0 ;
25248 : gpgme_import_result_t result;
25249 :
25250 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_import_result",&obj0)) SWIG_fail;
25251 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25252 2 : if (!SWIG_IsOK(res1)) {
25253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25254 : }
25255 2 : arg1 = (gpgme_ctx_t)(argp1);
25256 : {
25257 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25258 2 : result = (gpgme_import_result_t)gpgme_op_import_result(arg1);
25259 2 : SWIG_PYTHON_THREAD_END_ALLOW;
25260 : }
25261 : {
25262 : PyObject *fragile;
25263 2 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_import_result,
25264 : 0 );
25265 2 : resultobj = _gpg_wrap_result(fragile, "ImportResult");
25266 2 : Py_DECREF(fragile);
25267 : }
25268 : return resultobj;
25269 : fail:
25270 : return NULL;
25271 : }
25272 :
25273 :
25274 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25275 0 : PyObject *resultobj = 0;
25276 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25277 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
25278 0 : void *argp1 = 0 ;
25279 0 : int res1 = 0 ;
25280 0 : gpgme_data_t wrapper2 = NULL ;
25281 0 : PyObject *bytesio2 = NULL ;
25282 : Py_buffer view2 ;
25283 0 : int have_view2 = 0 ;
25284 0 : PyObject * obj0 = 0 ;
25285 0 : PyObject * obj1 = 0 ;
25286 : gpgme_error_t result;
25287 :
25288 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_start",&obj0,&obj1)) SWIG_fail;
25289 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25290 0 : if (!SWIG_IsOK(res1)) {
25291 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25292 : }
25293 0 : arg1 = (gpgme_ctx_t)(argp1);
25294 : {
25295 : /* If we create a temporary wrapper2 object, we will store it in
25296 : wrapperN, where N is 2. Here in this fragment, SWIG will
25297 : automatically append 2. */
25298 0 : memset(&view2, 0, sizeof view2);
25299 0 : if (obj1 == Py_None)
25300 0 : arg2 = NULL;
25301 : else {
25302 : PyObject *pypointer;
25303 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
25304 : &bytesio2, &view2);
25305 0 : if (pypointer == NULL)
25306 : return NULL;
25307 0 : have_view2 = !! view2.obj;
25308 :
25309 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
25310 :
25311 : /* Following code is from swig's python.swg. */
25312 :
25313 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
25314 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25315 0 : Py_DECREF(pypointer);
25316 : return NULL;
25317 : }
25318 0 : Py_DECREF(pypointer);
25319 : }
25320 : }
25321 : {
25322 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25323 0 : result = gpgme_op_import_start(arg1,arg2);
25324 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25325 : }
25326 : {
25327 0 : resultobj = PyLong_FromLong(result);
25328 : }
25329 : {
25330 : /* See whether we need to update the Python buffer. */
25331 0 : if (resultobj && wrapper2 && view2.buf)
25332 : {
25333 : int dirty;
25334 0 : char *new_data = NULL;
25335 : size_t new_size;
25336 :
25337 :
25338 0 : new_data = wrapper2->data.mem.buffer;
25339 0 : new_size = wrapper2->data.mem.length;
25340 0 : dirty = new_data != NULL;
25341 :
25342 :
25343 :
25344 :
25345 :
25346 :
25347 :
25348 0 : if (dirty)
25349 : {
25350 : /* The buffer is dirty. */
25351 0 : if (view2.readonly)
25352 : {
25353 0 : Py_XDECREF(resultobj);
25354 0 : resultobj = NULL;
25355 0 : PyErr_SetString(PyExc_ValueError,
25356 : "cannot update read-only buffer");
25357 : }
25358 :
25359 : /* See if we need to truncate the buffer. */
25360 0 : if (resultobj && view2.len != new_size)
25361 : {
25362 0 : if (bytesio2 == NULL)
25363 : {
25364 0 : Py_XDECREF(resultobj);
25365 0 : resultobj = NULL;
25366 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25367 : }
25368 : else
25369 : {
25370 : PyObject *retval;
25371 0 : PyBuffer_Release(&view2);
25372 : assert(view2.obj == NULL);
25373 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
25374 : "l", (long) new_size);
25375 0 : if (retval == NULL)
25376 : {
25377 0 : Py_XDECREF(resultobj);
25378 : resultobj = NULL;
25379 : }
25380 : else
25381 : {
25382 0 : Py_DECREF(retval);
25383 :
25384 0 : retval = PyObject_CallMethod(bytesio2,
25385 : "getbuffer", NULL);
25386 0 : if (retval == NULL
25387 0 : || PyObject_GetBuffer(retval, &view2,
25388 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25389 : {
25390 0 : Py_XDECREF(resultobj);
25391 : resultobj = NULL;
25392 : }
25393 :
25394 0 : Py_XDECREF(retval);
25395 :
25396 0 : if (resultobj && view2.len
25397 : != new_size)
25398 : {
25399 0 : Py_XDECREF(resultobj);
25400 0 : resultobj = NULL;
25401 0 : PyErr_Format(PyExc_ValueError,
25402 : "Expected buffer of length %zu, got %zi",
25403 : new_size,
25404 : view2.len);
25405 : }
25406 : }
25407 : }
25408 : }
25409 0 : if (resultobj)
25410 0 : memcpy(view2.buf, new_data, new_size);
25411 : }
25412 :
25413 :
25414 :
25415 : }
25416 :
25417 : /* Free the temporary wrapper, if any. */
25418 0 : if (wrapper2)
25419 0 : gpgme_data_release(wrapper2);
25420 0 : Py_XDECREF (bytesio2);
25421 0 : if (have_view2 && view2.buf)
25422 0 : PyBuffer_Release(&view2);
25423 : }
25424 : return resultobj;
25425 : fail:
25426 : {
25427 : /* See whether we need to update the Python buffer. */
25428 : if (resultobj && wrapper2 && view2.buf)
25429 : {
25430 : int dirty;
25431 : char *new_data = NULL;
25432 : size_t new_size;
25433 :
25434 :
25435 : new_data = wrapper2->data.mem.buffer;
25436 : new_size = wrapper2->data.mem.length;
25437 : dirty = new_data != NULL;
25438 :
25439 :
25440 :
25441 :
25442 :
25443 :
25444 :
25445 : if (dirty)
25446 : {
25447 : /* The buffer is dirty. */
25448 : if (view2.readonly)
25449 : {
25450 : Py_XDECREF(resultobj);
25451 : resultobj = NULL;
25452 : PyErr_SetString(PyExc_ValueError,
25453 : "cannot update read-only buffer");
25454 : }
25455 :
25456 : /* See if we need to truncate the buffer. */
25457 : if (resultobj && view2.len != new_size)
25458 : {
25459 : if (bytesio2 == NULL)
25460 : {
25461 : Py_XDECREF(resultobj);
25462 : resultobj = NULL;
25463 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25464 : }
25465 : else
25466 : {
25467 : PyObject *retval;
25468 : PyBuffer_Release(&view2);
25469 : assert(view2.obj == NULL);
25470 : retval = PyObject_CallMethod(bytesio2, "truncate",
25471 : "l", (long) new_size);
25472 : if (retval == NULL)
25473 : {
25474 : Py_XDECREF(resultobj);
25475 : resultobj = NULL;
25476 : }
25477 : else
25478 : {
25479 : Py_DECREF(retval);
25480 :
25481 : retval = PyObject_CallMethod(bytesio2,
25482 : "getbuffer", NULL);
25483 : if (retval == NULL
25484 : || PyObject_GetBuffer(retval, &view2,
25485 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25486 : {
25487 : Py_XDECREF(resultobj);
25488 : resultobj = NULL;
25489 : }
25490 :
25491 : Py_XDECREF(retval);
25492 :
25493 : if (resultobj && view2.len
25494 : != new_size)
25495 : {
25496 : Py_XDECREF(resultobj);
25497 : resultobj = NULL;
25498 : PyErr_Format(PyExc_ValueError,
25499 : "Expected buffer of length %zu, got %zi",
25500 : new_size,
25501 : view2.len);
25502 : }
25503 : }
25504 : }
25505 : }
25506 : if (resultobj)
25507 : memcpy(view2.buf, new_data, new_size);
25508 : }
25509 :
25510 :
25511 :
25512 : }
25513 :
25514 : /* Free the temporary wrapper, if any. */
25515 0 : if (wrapper2)
25516 0 : gpgme_data_release(wrapper2);
25517 0 : Py_XDECREF (bytesio2);
25518 : if (have_view2 && view2.buf)
25519 : PyBuffer_Release(&view2);
25520 : }
25521 : return NULL;
25522 : }
25523 :
25524 :
25525 4 : SWIGINTERN PyObject *_wrap_gpgme_op_import(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25526 4 : PyObject *resultobj = 0;
25527 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25528 4 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
25529 4 : void *argp1 = 0 ;
25530 4 : int res1 = 0 ;
25531 4 : gpgme_data_t wrapper2 = NULL ;
25532 4 : PyObject *bytesio2 = NULL ;
25533 : Py_buffer view2 ;
25534 4 : int have_view2 = 0 ;
25535 4 : PyObject * obj0 = 0 ;
25536 4 : PyObject * obj1 = 0 ;
25537 : gpgme_error_t result;
25538 :
25539 4 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import",&obj0,&obj1)) SWIG_fail;
25540 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25541 4 : if (!SWIG_IsOK(res1)) {
25542 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25543 : }
25544 4 : arg1 = (gpgme_ctx_t)(argp1);
25545 : {
25546 : /* If we create a temporary wrapper2 object, we will store it in
25547 : wrapperN, where N is 2. Here in this fragment, SWIG will
25548 : automatically append 2. */
25549 4 : memset(&view2, 0, sizeof view2);
25550 4 : if (obj1 == Py_None)
25551 0 : arg2 = NULL;
25552 : else {
25553 : PyObject *pypointer;
25554 4 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
25555 : &bytesio2, &view2);
25556 4 : if (pypointer == NULL)
25557 : return NULL;
25558 4 : have_view2 = !! view2.obj;
25559 :
25560 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
25561 :
25562 : /* Following code is from swig's python.swg. */
25563 :
25564 4 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
25565 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25566 0 : Py_DECREF(pypointer);
25567 : return NULL;
25568 : }
25569 4 : Py_DECREF(pypointer);
25570 : }
25571 : }
25572 : {
25573 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25574 4 : result = gpgme_op_import(arg1,arg2);
25575 4 : SWIG_PYTHON_THREAD_END_ALLOW;
25576 : }
25577 : {
25578 4 : resultobj = PyLong_FromLong(result);
25579 : }
25580 : {
25581 : /* See whether we need to update the Python buffer. */
25582 4 : if (resultobj && wrapper2 && view2.buf)
25583 : {
25584 : int dirty;
25585 0 : char *new_data = NULL;
25586 : size_t new_size;
25587 :
25588 :
25589 0 : new_data = wrapper2->data.mem.buffer;
25590 0 : new_size = wrapper2->data.mem.length;
25591 0 : dirty = new_data != NULL;
25592 :
25593 :
25594 :
25595 :
25596 :
25597 :
25598 :
25599 0 : if (dirty)
25600 : {
25601 : /* The buffer is dirty. */
25602 0 : if (view2.readonly)
25603 : {
25604 0 : Py_XDECREF(resultobj);
25605 0 : resultobj = NULL;
25606 0 : PyErr_SetString(PyExc_ValueError,
25607 : "cannot update read-only buffer");
25608 : }
25609 :
25610 : /* See if we need to truncate the buffer. */
25611 0 : if (resultobj && view2.len != new_size)
25612 : {
25613 0 : if (bytesio2 == NULL)
25614 : {
25615 0 : Py_XDECREF(resultobj);
25616 0 : resultobj = NULL;
25617 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25618 : }
25619 : else
25620 : {
25621 : PyObject *retval;
25622 0 : PyBuffer_Release(&view2);
25623 : assert(view2.obj == NULL);
25624 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
25625 : "l", (long) new_size);
25626 0 : if (retval == NULL)
25627 : {
25628 0 : Py_XDECREF(resultobj);
25629 : resultobj = NULL;
25630 : }
25631 : else
25632 : {
25633 0 : Py_DECREF(retval);
25634 :
25635 0 : retval = PyObject_CallMethod(bytesio2,
25636 : "getbuffer", NULL);
25637 0 : if (retval == NULL
25638 0 : || PyObject_GetBuffer(retval, &view2,
25639 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25640 : {
25641 0 : Py_XDECREF(resultobj);
25642 : resultobj = NULL;
25643 : }
25644 :
25645 0 : Py_XDECREF(retval);
25646 :
25647 0 : if (resultobj && view2.len
25648 : != new_size)
25649 : {
25650 0 : Py_XDECREF(resultobj);
25651 0 : resultobj = NULL;
25652 0 : PyErr_Format(PyExc_ValueError,
25653 : "Expected buffer of length %zu, got %zi",
25654 : new_size,
25655 : view2.len);
25656 : }
25657 : }
25658 : }
25659 : }
25660 0 : if (resultobj)
25661 0 : memcpy(view2.buf, new_data, new_size);
25662 : }
25663 :
25664 :
25665 :
25666 : }
25667 :
25668 : /* Free the temporary wrapper, if any. */
25669 4 : if (wrapper2)
25670 2 : gpgme_data_release(wrapper2);
25671 4 : Py_XDECREF (bytesio2);
25672 4 : if (have_view2 && view2.buf)
25673 0 : PyBuffer_Release(&view2);
25674 : }
25675 : return resultobj;
25676 : fail:
25677 : {
25678 : /* See whether we need to update the Python buffer. */
25679 : if (resultobj && wrapper2 && view2.buf)
25680 : {
25681 : int dirty;
25682 : char *new_data = NULL;
25683 : size_t new_size;
25684 :
25685 :
25686 : new_data = wrapper2->data.mem.buffer;
25687 : new_size = wrapper2->data.mem.length;
25688 : dirty = new_data != NULL;
25689 :
25690 :
25691 :
25692 :
25693 :
25694 :
25695 :
25696 : if (dirty)
25697 : {
25698 : /* The buffer is dirty. */
25699 : if (view2.readonly)
25700 : {
25701 : Py_XDECREF(resultobj);
25702 : resultobj = NULL;
25703 : PyErr_SetString(PyExc_ValueError,
25704 : "cannot update read-only buffer");
25705 : }
25706 :
25707 : /* See if we need to truncate the buffer. */
25708 : if (resultobj && view2.len != new_size)
25709 : {
25710 : if (bytesio2 == NULL)
25711 : {
25712 : Py_XDECREF(resultobj);
25713 : resultobj = NULL;
25714 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
25715 : }
25716 : else
25717 : {
25718 : PyObject *retval;
25719 : PyBuffer_Release(&view2);
25720 : assert(view2.obj == NULL);
25721 : retval = PyObject_CallMethod(bytesio2, "truncate",
25722 : "l", (long) new_size);
25723 : if (retval == NULL)
25724 : {
25725 : Py_XDECREF(resultobj);
25726 : resultobj = NULL;
25727 : }
25728 : else
25729 : {
25730 : Py_DECREF(retval);
25731 :
25732 : retval = PyObject_CallMethod(bytesio2,
25733 : "getbuffer", NULL);
25734 : if (retval == NULL
25735 : || PyObject_GetBuffer(retval, &view2,
25736 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
25737 : {
25738 : Py_XDECREF(resultobj);
25739 : resultobj = NULL;
25740 : }
25741 :
25742 : Py_XDECREF(retval);
25743 :
25744 : if (resultobj && view2.len
25745 : != new_size)
25746 : {
25747 : Py_XDECREF(resultobj);
25748 : resultobj = NULL;
25749 : PyErr_Format(PyExc_ValueError,
25750 : "Expected buffer of length %zu, got %zi",
25751 : new_size,
25752 : view2.len);
25753 : }
25754 : }
25755 : }
25756 : }
25757 : if (resultobj)
25758 : memcpy(view2.buf, new_data, new_size);
25759 : }
25760 :
25761 :
25762 :
25763 : }
25764 :
25765 : /* Free the temporary wrapper, if any. */
25766 0 : if (wrapper2)
25767 0 : gpgme_data_release(wrapper2);
25768 0 : Py_XDECREF (bytesio2);
25769 : if (have_view2 && view2.buf)
25770 : PyBuffer_Release(&view2);
25771 : }
25772 : return NULL;
25773 : }
25774 :
25775 :
25776 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25777 0 : PyObject *resultobj = 0;
25778 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25779 : gpgme_key_t *arg2 ;
25780 0 : void *argp1 = 0 ;
25781 0 : int res1 = 0 ;
25782 0 : PyObject * obj0 = 0 ;
25783 0 : PyObject * obj1 = 0 ;
25784 : gpgme_error_t result;
25785 :
25786 : {
25787 0 : arg2 = NULL;
25788 : }
25789 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys_start",&obj0,&obj1)) SWIG_fail;
25790 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25791 0 : if (!SWIG_IsOK(res1)) {
25792 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25793 : }
25794 0 : arg1 = (gpgme_ctx_t)(argp1);
25795 : {
25796 0 : int i, numb = 0;
25797 0 : if (!PySequence_Check(obj1)) {
25798 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
25799 : 2);
25800 0 : return NULL;
25801 : }
25802 0 : if((numb = PySequence_Length(obj1)) != 0) {
25803 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
25804 0 : for(i=0; i<numb; i++) {
25805 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
25806 :
25807 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
25808 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
25809 :
25810 : /* Following code is from swig's python.swg. */
25811 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25812 0 : Py_DECREF(pypointer);
25813 0 : PyErr_Format(PyExc_TypeError,
25814 : "arg %d: list must contain only gpgme_key_ts, got %s "
25815 : "at position %d",
25816 0 : 2, pypointer->ob_type->tp_name, i);
25817 0 : free(arg2);
25818 0 : return NULL;
25819 : }
25820 0 : Py_DECREF(pypointer);
25821 : }
25822 0 : arg2[numb] = NULL;
25823 : }
25824 : }
25825 : {
25826 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25827 0 : result = gpgme_op_import_keys_start(arg1,arg2);
25828 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25829 : }
25830 : {
25831 0 : resultobj = PyLong_FromLong(result);
25832 : }
25833 : {
25834 0 : if (arg2) free(arg2);
25835 : }
25836 : return resultobj;
25837 : fail:
25838 : {
25839 : if (arg2) free(arg2);
25840 : }
25841 : return NULL;
25842 : }
25843 :
25844 :
25845 0 : SWIGINTERN PyObject *_wrap_gpgme_op_import_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25846 0 : PyObject *resultobj = 0;
25847 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25848 : gpgme_key_t *arg2 ;
25849 0 : void *argp1 = 0 ;
25850 0 : int res1 = 0 ;
25851 0 : PyObject * obj0 = 0 ;
25852 0 : PyObject * obj1 = 0 ;
25853 : gpgme_error_t result;
25854 :
25855 : {
25856 0 : arg2 = NULL;
25857 : }
25858 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_import_keys",&obj0,&obj1)) SWIG_fail;
25859 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25860 0 : if (!SWIG_IsOK(res1)) {
25861 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_import_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25862 : }
25863 0 : arg1 = (gpgme_ctx_t)(argp1);
25864 : {
25865 0 : int i, numb = 0;
25866 0 : if (!PySequence_Check(obj1)) {
25867 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
25868 : 2);
25869 0 : return NULL;
25870 : }
25871 0 : if((numb = PySequence_Length(obj1)) != 0) {
25872 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
25873 0 : for(i=0; i<numb; i++) {
25874 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
25875 :
25876 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
25877 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
25878 :
25879 : /* Following code is from swig's python.swg. */
25880 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25881 0 : Py_DECREF(pypointer);
25882 0 : PyErr_Format(PyExc_TypeError,
25883 : "arg %d: list must contain only gpgme_key_ts, got %s "
25884 : "at position %d",
25885 0 : 2, pypointer->ob_type->tp_name, i);
25886 0 : free(arg2);
25887 0 : return NULL;
25888 : }
25889 0 : Py_DECREF(pypointer);
25890 : }
25891 0 : arg2[numb] = NULL;
25892 : }
25893 : }
25894 : {
25895 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25896 0 : result = gpgme_op_import_keys(arg1,arg2);
25897 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25898 : }
25899 : {
25900 0 : resultobj = PyLong_FromLong(result);
25901 : }
25902 : {
25903 0 : if (arg2) free(arg2);
25904 : }
25905 : return resultobj;
25906 : fail:
25907 : {
25908 : if (arg2) free(arg2);
25909 : }
25910 : return NULL;
25911 : }
25912 :
25913 :
25914 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 0 : PyObject *resultobj = 0;
25916 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
25917 0 : char *arg2 = (char *) 0 ;
25918 : gpgme_export_mode_t arg3 ;
25919 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
25920 0 : void *argp1 = 0 ;
25921 0 : int res1 = 0 ;
25922 0 : PyObject *encodedInput2 = NULL ;
25923 : unsigned int val3 ;
25924 0 : int ecode3 = 0 ;
25925 0 : gpgme_data_t wrapper4 = NULL ;
25926 0 : PyObject *bytesio4 = NULL ;
25927 : Py_buffer view4 ;
25928 0 : int have_view4 = 0 ;
25929 0 : PyObject * obj0 = 0 ;
25930 0 : PyObject * obj1 = 0 ;
25931 0 : PyObject * obj2 = 0 ;
25932 0 : PyObject * obj3 = 0 ;
25933 : gpgme_error_t result;
25934 :
25935 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
25936 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
25937 0 : if (!SWIG_IsOK(res1)) {
25938 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
25939 : }
25940 0 : arg1 = (gpgme_ctx_t)(argp1);
25941 : {
25942 0 : if (obj1 == Py_None)
25943 : arg2 = NULL;
25944 0 : else if (PyUnicode_Check(obj1))
25945 : {
25946 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
25947 0 : if (encodedInput2 == NULL)
25948 : return NULL;
25949 0 : arg2 = PyBytes_AsString(encodedInput2);
25950 : }
25951 0 : else if (PyBytes_Check(obj1))
25952 0 : arg2 = PyBytes_AsString(obj1);
25953 : else {
25954 0 : PyErr_Format(PyExc_TypeError,
25955 : "arg %d: expected str, bytes, or None, got %s",
25956 : 2, obj1->ob_type->tp_name);
25957 0 : return NULL;
25958 : }
25959 : }
25960 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
25961 0 : if (!SWIG_IsOK(ecode3)) {
25962 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
25963 : }
25964 0 : arg3 = (gpgme_export_mode_t)(val3);
25965 : {
25966 : /* If we create a temporary wrapper4 object, we will store it in
25967 : wrapperN, where N is 4. Here in this fragment, SWIG will
25968 : automatically append 4. */
25969 0 : memset(&view4, 0, sizeof view4);
25970 0 : if (obj3 == Py_None)
25971 0 : arg4 = NULL;
25972 : else {
25973 : PyObject *pypointer;
25974 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
25975 : &bytesio4, &view4);
25976 0 : if (pypointer == NULL)
25977 : return NULL;
25978 0 : have_view4 = !! view4.obj;
25979 :
25980 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
25981 :
25982 : /* Following code is from swig's python.swg. */
25983 :
25984 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
25985 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
25986 0 : Py_DECREF(pypointer);
25987 : return NULL;
25988 : }
25989 0 : Py_DECREF(pypointer);
25990 : }
25991 : }
25992 : {
25993 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
25994 0 : result = gpgme_op_export_start(arg1,(char const *)arg2,arg3,arg4);
25995 0 : SWIG_PYTHON_THREAD_END_ALLOW;
25996 : }
25997 : {
25998 0 : resultobj = PyLong_FromLong(result);
25999 : }
26000 : {
26001 0 : Py_XDECREF(encodedInput2);
26002 : }
26003 : {
26004 : /* See whether we need to update the Python buffer. */
26005 0 : if (resultobj && wrapper4 && view4.buf)
26006 : {
26007 : int dirty;
26008 0 : char *new_data = NULL;
26009 : size_t new_size;
26010 :
26011 :
26012 0 : new_data = wrapper4->data.mem.buffer;
26013 0 : new_size = wrapper4->data.mem.length;
26014 0 : dirty = new_data != NULL;
26015 :
26016 :
26017 :
26018 :
26019 :
26020 :
26021 :
26022 0 : if (dirty)
26023 : {
26024 : /* The buffer is dirty. */
26025 0 : if (view4.readonly)
26026 : {
26027 0 : Py_XDECREF(resultobj);
26028 0 : resultobj = NULL;
26029 0 : PyErr_SetString(PyExc_ValueError,
26030 : "cannot update read-only buffer");
26031 : }
26032 :
26033 : /* See if we need to truncate the buffer. */
26034 0 : if (resultobj && view4.len != new_size)
26035 : {
26036 0 : if (bytesio4 == NULL)
26037 : {
26038 0 : Py_XDECREF(resultobj);
26039 0 : resultobj = NULL;
26040 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26041 : }
26042 : else
26043 : {
26044 : PyObject *retval;
26045 0 : PyBuffer_Release(&view4);
26046 : assert(view4.obj == NULL);
26047 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
26048 : "l", (long) new_size);
26049 0 : if (retval == NULL)
26050 : {
26051 0 : Py_XDECREF(resultobj);
26052 : resultobj = NULL;
26053 : }
26054 : else
26055 : {
26056 0 : Py_DECREF(retval);
26057 :
26058 0 : retval = PyObject_CallMethod(bytesio4,
26059 : "getbuffer", NULL);
26060 0 : if (retval == NULL
26061 0 : || PyObject_GetBuffer(retval, &view4,
26062 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26063 : {
26064 0 : Py_XDECREF(resultobj);
26065 : resultobj = NULL;
26066 : }
26067 :
26068 0 : Py_XDECREF(retval);
26069 :
26070 0 : if (resultobj && view4.len
26071 : != new_size)
26072 : {
26073 0 : Py_XDECREF(resultobj);
26074 0 : resultobj = NULL;
26075 0 : PyErr_Format(PyExc_ValueError,
26076 : "Expected buffer of length %zu, got %zi",
26077 : new_size,
26078 : view4.len);
26079 : }
26080 : }
26081 : }
26082 : }
26083 0 : if (resultobj)
26084 0 : memcpy(view4.buf, new_data, new_size);
26085 : }
26086 :
26087 :
26088 :
26089 : }
26090 :
26091 : /* Free the temporary wrapper, if any. */
26092 0 : if (wrapper4)
26093 0 : gpgme_data_release(wrapper4);
26094 0 : Py_XDECREF (bytesio4);
26095 0 : if (have_view4 && view4.buf)
26096 0 : PyBuffer_Release(&view4);
26097 : }
26098 : return resultobj;
26099 : fail:
26100 : {
26101 0 : Py_XDECREF(encodedInput2);
26102 : }
26103 : {
26104 : /* See whether we need to update the Python buffer. */
26105 : if (resultobj && wrapper4 && view4.buf)
26106 : {
26107 : int dirty;
26108 : char *new_data = NULL;
26109 : size_t new_size;
26110 :
26111 :
26112 : new_data = wrapper4->data.mem.buffer;
26113 : new_size = wrapper4->data.mem.length;
26114 : dirty = new_data != NULL;
26115 :
26116 :
26117 :
26118 :
26119 :
26120 :
26121 :
26122 : if (dirty)
26123 : {
26124 : /* The buffer is dirty. */
26125 : if (view4.readonly)
26126 : {
26127 : Py_XDECREF(resultobj);
26128 : resultobj = NULL;
26129 : PyErr_SetString(PyExc_ValueError,
26130 : "cannot update read-only buffer");
26131 : }
26132 :
26133 : /* See if we need to truncate the buffer. */
26134 : if (resultobj && view4.len != new_size)
26135 : {
26136 : if (bytesio4 == NULL)
26137 : {
26138 : Py_XDECREF(resultobj);
26139 : resultobj = NULL;
26140 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26141 : }
26142 : else
26143 : {
26144 : PyObject *retval;
26145 : PyBuffer_Release(&view4);
26146 : assert(view4.obj == NULL);
26147 : retval = PyObject_CallMethod(bytesio4, "truncate",
26148 : "l", (long) new_size);
26149 : if (retval == NULL)
26150 : {
26151 : Py_XDECREF(resultobj);
26152 : resultobj = NULL;
26153 : }
26154 : else
26155 : {
26156 : Py_DECREF(retval);
26157 :
26158 : retval = PyObject_CallMethod(bytesio4,
26159 : "getbuffer", NULL);
26160 : if (retval == NULL
26161 : || PyObject_GetBuffer(retval, &view4,
26162 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26163 : {
26164 : Py_XDECREF(resultobj);
26165 : resultobj = NULL;
26166 : }
26167 :
26168 : Py_XDECREF(retval);
26169 :
26170 : if (resultobj && view4.len
26171 : != new_size)
26172 : {
26173 : Py_XDECREF(resultobj);
26174 : resultobj = NULL;
26175 : PyErr_Format(PyExc_ValueError,
26176 : "Expected buffer of length %zu, got %zi",
26177 : new_size,
26178 : view4.len);
26179 : }
26180 : }
26181 : }
26182 : }
26183 : if (resultobj)
26184 : memcpy(view4.buf, new_data, new_size);
26185 : }
26186 :
26187 :
26188 :
26189 : }
26190 :
26191 : /* Free the temporary wrapper, if any. */
26192 0 : if (wrapper4)
26193 0 : gpgme_data_release(wrapper4);
26194 0 : Py_XDECREF (bytesio4);
26195 : if (have_view4 && view4.buf)
26196 : PyBuffer_Release(&view4);
26197 : }
26198 : return NULL;
26199 : }
26200 :
26201 :
26202 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26203 0 : PyObject *resultobj = 0;
26204 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26205 0 : char *arg2 = (char *) 0 ;
26206 : gpgme_export_mode_t arg3 ;
26207 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
26208 0 : void *argp1 = 0 ;
26209 0 : int res1 = 0 ;
26210 0 : PyObject *encodedInput2 = NULL ;
26211 : unsigned int val3 ;
26212 0 : int ecode3 = 0 ;
26213 0 : gpgme_data_t wrapper4 = NULL ;
26214 0 : PyObject *bytesio4 = NULL ;
26215 : Py_buffer view4 ;
26216 0 : int have_view4 = 0 ;
26217 0 : PyObject * obj0 = 0 ;
26218 0 : PyObject * obj1 = 0 ;
26219 0 : PyObject * obj2 = 0 ;
26220 0 : PyObject * obj3 = 0 ;
26221 : gpgme_error_t result;
26222 :
26223 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26224 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26225 0 : if (!SWIG_IsOK(res1)) {
26226 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26227 : }
26228 0 : arg1 = (gpgme_ctx_t)(argp1);
26229 : {
26230 0 : if (obj1 == Py_None)
26231 : arg2 = NULL;
26232 0 : else if (PyUnicode_Check(obj1))
26233 : {
26234 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
26235 0 : if (encodedInput2 == NULL)
26236 : return NULL;
26237 0 : arg2 = PyBytes_AsString(encodedInput2);
26238 : }
26239 0 : else if (PyBytes_Check(obj1))
26240 0 : arg2 = PyBytes_AsString(obj1);
26241 : else {
26242 0 : PyErr_Format(PyExc_TypeError,
26243 : "arg %d: expected str, bytes, or None, got %s",
26244 : 2, obj1->ob_type->tp_name);
26245 0 : return NULL;
26246 : }
26247 : }
26248 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
26249 0 : if (!SWIG_IsOK(ecode3)) {
26250 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
26251 : }
26252 0 : arg3 = (gpgme_export_mode_t)(val3);
26253 : {
26254 : /* If we create a temporary wrapper4 object, we will store it in
26255 : wrapperN, where N is 4. Here in this fragment, SWIG will
26256 : automatically append 4. */
26257 0 : memset(&view4, 0, sizeof view4);
26258 0 : if (obj3 == Py_None)
26259 0 : arg4 = NULL;
26260 : else {
26261 : PyObject *pypointer;
26262 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
26263 : &bytesio4, &view4);
26264 0 : if (pypointer == NULL)
26265 : return NULL;
26266 0 : have_view4 = !! view4.obj;
26267 :
26268 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
26269 :
26270 : /* Following code is from swig's python.swg. */
26271 :
26272 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
26273 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26274 0 : Py_DECREF(pypointer);
26275 : return NULL;
26276 : }
26277 0 : Py_DECREF(pypointer);
26278 : }
26279 : }
26280 : {
26281 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26282 0 : result = gpgme_op_export(arg1,(char const *)arg2,arg3,arg4);
26283 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26284 : }
26285 : {
26286 0 : resultobj = PyLong_FromLong(result);
26287 : }
26288 : {
26289 0 : Py_XDECREF(encodedInput2);
26290 : }
26291 : {
26292 : /* See whether we need to update the Python buffer. */
26293 0 : if (resultobj && wrapper4 && view4.buf)
26294 : {
26295 : int dirty;
26296 0 : char *new_data = NULL;
26297 : size_t new_size;
26298 :
26299 :
26300 0 : new_data = wrapper4->data.mem.buffer;
26301 0 : new_size = wrapper4->data.mem.length;
26302 0 : dirty = new_data != NULL;
26303 :
26304 :
26305 :
26306 :
26307 :
26308 :
26309 :
26310 0 : if (dirty)
26311 : {
26312 : /* The buffer is dirty. */
26313 0 : if (view4.readonly)
26314 : {
26315 0 : Py_XDECREF(resultobj);
26316 0 : resultobj = NULL;
26317 0 : PyErr_SetString(PyExc_ValueError,
26318 : "cannot update read-only buffer");
26319 : }
26320 :
26321 : /* See if we need to truncate the buffer. */
26322 0 : if (resultobj && view4.len != new_size)
26323 : {
26324 0 : if (bytesio4 == NULL)
26325 : {
26326 0 : Py_XDECREF(resultobj);
26327 0 : resultobj = NULL;
26328 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26329 : }
26330 : else
26331 : {
26332 : PyObject *retval;
26333 0 : PyBuffer_Release(&view4);
26334 : assert(view4.obj == NULL);
26335 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
26336 : "l", (long) new_size);
26337 0 : if (retval == NULL)
26338 : {
26339 0 : Py_XDECREF(resultobj);
26340 : resultobj = NULL;
26341 : }
26342 : else
26343 : {
26344 0 : Py_DECREF(retval);
26345 :
26346 0 : retval = PyObject_CallMethod(bytesio4,
26347 : "getbuffer", NULL);
26348 0 : if (retval == NULL
26349 0 : || PyObject_GetBuffer(retval, &view4,
26350 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26351 : {
26352 0 : Py_XDECREF(resultobj);
26353 : resultobj = NULL;
26354 : }
26355 :
26356 0 : Py_XDECREF(retval);
26357 :
26358 0 : if (resultobj && view4.len
26359 : != new_size)
26360 : {
26361 0 : Py_XDECREF(resultobj);
26362 0 : resultobj = NULL;
26363 0 : PyErr_Format(PyExc_ValueError,
26364 : "Expected buffer of length %zu, got %zi",
26365 : new_size,
26366 : view4.len);
26367 : }
26368 : }
26369 : }
26370 : }
26371 0 : if (resultobj)
26372 0 : memcpy(view4.buf, new_data, new_size);
26373 : }
26374 :
26375 :
26376 :
26377 : }
26378 :
26379 : /* Free the temporary wrapper, if any. */
26380 0 : if (wrapper4)
26381 0 : gpgme_data_release(wrapper4);
26382 0 : Py_XDECREF (bytesio4);
26383 0 : if (have_view4 && view4.buf)
26384 0 : PyBuffer_Release(&view4);
26385 : }
26386 : return resultobj;
26387 : fail:
26388 : {
26389 0 : Py_XDECREF(encodedInput2);
26390 : }
26391 : {
26392 : /* See whether we need to update the Python buffer. */
26393 : if (resultobj && wrapper4 && view4.buf)
26394 : {
26395 : int dirty;
26396 : char *new_data = NULL;
26397 : size_t new_size;
26398 :
26399 :
26400 : new_data = wrapper4->data.mem.buffer;
26401 : new_size = wrapper4->data.mem.length;
26402 : dirty = new_data != NULL;
26403 :
26404 :
26405 :
26406 :
26407 :
26408 :
26409 :
26410 : if (dirty)
26411 : {
26412 : /* The buffer is dirty. */
26413 : if (view4.readonly)
26414 : {
26415 : Py_XDECREF(resultobj);
26416 : resultobj = NULL;
26417 : PyErr_SetString(PyExc_ValueError,
26418 : "cannot update read-only buffer");
26419 : }
26420 :
26421 : /* See if we need to truncate the buffer. */
26422 : if (resultobj && view4.len != new_size)
26423 : {
26424 : if (bytesio4 == NULL)
26425 : {
26426 : Py_XDECREF(resultobj);
26427 : resultobj = NULL;
26428 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26429 : }
26430 : else
26431 : {
26432 : PyObject *retval;
26433 : PyBuffer_Release(&view4);
26434 : assert(view4.obj == NULL);
26435 : retval = PyObject_CallMethod(bytesio4, "truncate",
26436 : "l", (long) new_size);
26437 : if (retval == NULL)
26438 : {
26439 : Py_XDECREF(resultobj);
26440 : resultobj = NULL;
26441 : }
26442 : else
26443 : {
26444 : Py_DECREF(retval);
26445 :
26446 : retval = PyObject_CallMethod(bytesio4,
26447 : "getbuffer", NULL);
26448 : if (retval == NULL
26449 : || PyObject_GetBuffer(retval, &view4,
26450 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26451 : {
26452 : Py_XDECREF(resultobj);
26453 : resultobj = NULL;
26454 : }
26455 :
26456 : Py_XDECREF(retval);
26457 :
26458 : if (resultobj && view4.len
26459 : != new_size)
26460 : {
26461 : Py_XDECREF(resultobj);
26462 : resultobj = NULL;
26463 : PyErr_Format(PyExc_ValueError,
26464 : "Expected buffer of length %zu, got %zi",
26465 : new_size,
26466 : view4.len);
26467 : }
26468 : }
26469 : }
26470 : }
26471 : if (resultobj)
26472 : memcpy(view4.buf, new_data, new_size);
26473 : }
26474 :
26475 :
26476 :
26477 : }
26478 :
26479 : /* Free the temporary wrapper, if any. */
26480 0 : if (wrapper4)
26481 0 : gpgme_data_release(wrapper4);
26482 0 : Py_XDECREF (bytesio4);
26483 : if (have_view4 && view4.buf)
26484 : PyBuffer_Release(&view4);
26485 : }
26486 : return NULL;
26487 : }
26488 :
26489 :
26490 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26491 0 : PyObject *resultobj = 0;
26492 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26493 : char **arg2 ;
26494 : gpgme_export_mode_t arg3 ;
26495 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
26496 0 : void *argp1 = 0 ;
26497 0 : int res1 = 0 ;
26498 0 : void *vector2 = NULL ;
26499 : size_t size2 ;
26500 0 : PyObject **pyVector2 = NULL ;
26501 : unsigned int val3 ;
26502 0 : int ecode3 = 0 ;
26503 0 : gpgme_data_t wrapper4 = NULL ;
26504 0 : PyObject *bytesio4 = NULL ;
26505 : Py_buffer view4 ;
26506 0 : int have_view4 = 0 ;
26507 0 : PyObject * obj0 = 0 ;
26508 0 : PyObject * obj1 = 0 ;
26509 0 : PyObject * obj2 = 0 ;
26510 0 : PyObject * obj3 = 0 ;
26511 : gpgme_error_t result;
26512 :
26513 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26514 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26515 0 : if (!SWIG_IsOK(res1)) {
26516 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26517 : }
26518 0 : arg1 = (gpgme_ctx_t)(argp1);
26519 : {
26520 : /* Check if is a list */
26521 0 : if (PyList_Check(obj1)) {
26522 : size_t i, j;
26523 0 : size2 = PyList_Size(obj1);
26524 0 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
26525 0 : pyVector2 = calloc(sizeof *pyVector2, size2);
26526 :
26527 0 : for (i = 0; i < size2; i++) {
26528 0 : PyObject *o = PyList_GetItem(obj1,i);
26529 0 : if (PyUnicode_Check(o))
26530 : {
26531 0 : pyVector2[i] = PyUnicode_AsUTF8String(o);
26532 0 : if (pyVector2[i] == NULL)
26533 : {
26534 0 : free(vector2);
26535 0 : for (j = 0; j < i; j++)
26536 0 : Py_XDECREF(pyVector2[j]);
26537 : return NULL;
26538 : }
26539 0 : arg2[i] = PyBytes_AsString(pyVector2[i]);
26540 : }
26541 0 : else if (PyString_Check(o))
26542 0 : arg2[i] = PyString_AsString(o);
26543 : else {
26544 0 : PyErr_Format(PyExc_TypeError,
26545 : "arg %d: list must contain only str or bytes, got %s "
26546 : "at position %d",
26547 : 2, o->ob_type->tp_name, i);
26548 0 : free(arg2);
26549 0 : return NULL;
26550 : }
26551 : }
26552 0 : arg2[i] = NULL;
26553 : } else {
26554 0 : PyErr_Format(PyExc_TypeError,
26555 : "arg %d: expected a list of str or bytes, got %s",
26556 : 2, obj1->ob_type->tp_name);
26557 0 : return NULL;
26558 : }
26559 : }
26560 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
26561 0 : if (!SWIG_IsOK(ecode3)) {
26562 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
26563 : }
26564 0 : arg3 = (gpgme_export_mode_t)(val3);
26565 : {
26566 : /* If we create a temporary wrapper4 object, we will store it in
26567 : wrapperN, where N is 4. Here in this fragment, SWIG will
26568 : automatically append 4. */
26569 0 : memset(&view4, 0, sizeof view4);
26570 0 : if (obj3 == Py_None)
26571 0 : arg4 = NULL;
26572 : else {
26573 : PyObject *pypointer;
26574 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
26575 : &bytesio4, &view4);
26576 0 : if (pypointer == NULL)
26577 : return NULL;
26578 0 : have_view4 = !! view4.obj;
26579 :
26580 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
26581 :
26582 : /* Following code is from swig's python.swg. */
26583 :
26584 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
26585 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26586 0 : Py_DECREF(pypointer);
26587 : return NULL;
26588 : }
26589 0 : Py_DECREF(pypointer);
26590 : }
26591 : }
26592 : {
26593 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26594 0 : result = gpgme_op_export_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
26595 0 : SWIG_PYTHON_THREAD_END_ALLOW;
26596 : }
26597 : {
26598 0 : resultobj = PyLong_FromLong(result);
26599 : }
26600 : {
26601 : size_t i;
26602 0 : free(vector2);
26603 0 : for (i = 0; i < size2; i++)
26604 0 : Py_XDECREF(pyVector2[i]);
26605 : }
26606 : {
26607 : /* See whether we need to update the Python buffer. */
26608 0 : if (resultobj && wrapper4 && view4.buf)
26609 : {
26610 : int dirty;
26611 0 : char *new_data = NULL;
26612 : size_t new_size;
26613 :
26614 :
26615 0 : new_data = wrapper4->data.mem.buffer;
26616 0 : new_size = wrapper4->data.mem.length;
26617 0 : dirty = new_data != NULL;
26618 :
26619 :
26620 :
26621 :
26622 :
26623 :
26624 :
26625 0 : if (dirty)
26626 : {
26627 : /* The buffer is dirty. */
26628 0 : if (view4.readonly)
26629 : {
26630 0 : Py_XDECREF(resultobj);
26631 0 : resultobj = NULL;
26632 0 : PyErr_SetString(PyExc_ValueError,
26633 : "cannot update read-only buffer");
26634 : }
26635 :
26636 : /* See if we need to truncate the buffer. */
26637 0 : if (resultobj && view4.len != new_size)
26638 : {
26639 0 : if (bytesio4 == NULL)
26640 : {
26641 0 : Py_XDECREF(resultobj);
26642 0 : resultobj = NULL;
26643 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26644 : }
26645 : else
26646 : {
26647 : PyObject *retval;
26648 0 : PyBuffer_Release(&view4);
26649 : assert(view4.obj == NULL);
26650 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
26651 : "l", (long) new_size);
26652 0 : if (retval == NULL)
26653 : {
26654 0 : Py_XDECREF(resultobj);
26655 : resultobj = NULL;
26656 : }
26657 : else
26658 : {
26659 0 : Py_DECREF(retval);
26660 :
26661 0 : retval = PyObject_CallMethod(bytesio4,
26662 : "getbuffer", NULL);
26663 0 : if (retval == NULL
26664 0 : || PyObject_GetBuffer(retval, &view4,
26665 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26666 : {
26667 0 : Py_XDECREF(resultobj);
26668 : resultobj = NULL;
26669 : }
26670 :
26671 0 : Py_XDECREF(retval);
26672 :
26673 0 : if (resultobj && view4.len
26674 : != new_size)
26675 : {
26676 0 : Py_XDECREF(resultobj);
26677 0 : resultobj = NULL;
26678 0 : PyErr_Format(PyExc_ValueError,
26679 : "Expected buffer of length %zu, got %zi",
26680 : new_size,
26681 : view4.len);
26682 : }
26683 : }
26684 : }
26685 : }
26686 0 : if (resultobj)
26687 0 : memcpy(view4.buf, new_data, new_size);
26688 : }
26689 :
26690 :
26691 :
26692 : }
26693 :
26694 : /* Free the temporary wrapper, if any. */
26695 0 : if (wrapper4)
26696 0 : gpgme_data_release(wrapper4);
26697 0 : Py_XDECREF (bytesio4);
26698 0 : if (have_view4 && view4.buf)
26699 0 : PyBuffer_Release(&view4);
26700 : }
26701 : return resultobj;
26702 : fail:
26703 : {
26704 : size_t i;
26705 0 : free(vector2);
26706 0 : for (i = 0; i < size2; i++)
26707 0 : Py_XDECREF(pyVector2[i]);
26708 : }
26709 : {
26710 : /* See whether we need to update the Python buffer. */
26711 : if (resultobj && wrapper4 && view4.buf)
26712 : {
26713 : int dirty;
26714 : char *new_data = NULL;
26715 : size_t new_size;
26716 :
26717 :
26718 : new_data = wrapper4->data.mem.buffer;
26719 : new_size = wrapper4->data.mem.length;
26720 : dirty = new_data != NULL;
26721 :
26722 :
26723 :
26724 :
26725 :
26726 :
26727 :
26728 : if (dirty)
26729 : {
26730 : /* The buffer is dirty. */
26731 : if (view4.readonly)
26732 : {
26733 : Py_XDECREF(resultobj);
26734 : resultobj = NULL;
26735 : PyErr_SetString(PyExc_ValueError,
26736 : "cannot update read-only buffer");
26737 : }
26738 :
26739 : /* See if we need to truncate the buffer. */
26740 : if (resultobj && view4.len != new_size)
26741 : {
26742 : if (bytesio4 == NULL)
26743 : {
26744 : Py_XDECREF(resultobj);
26745 : resultobj = NULL;
26746 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26747 : }
26748 : else
26749 : {
26750 : PyObject *retval;
26751 : PyBuffer_Release(&view4);
26752 : assert(view4.obj == NULL);
26753 : retval = PyObject_CallMethod(bytesio4, "truncate",
26754 : "l", (long) new_size);
26755 : if (retval == NULL)
26756 : {
26757 : Py_XDECREF(resultobj);
26758 : resultobj = NULL;
26759 : }
26760 : else
26761 : {
26762 : Py_DECREF(retval);
26763 :
26764 : retval = PyObject_CallMethod(bytesio4,
26765 : "getbuffer", NULL);
26766 : if (retval == NULL
26767 : || PyObject_GetBuffer(retval, &view4,
26768 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26769 : {
26770 : Py_XDECREF(resultobj);
26771 : resultobj = NULL;
26772 : }
26773 :
26774 : Py_XDECREF(retval);
26775 :
26776 : if (resultobj && view4.len
26777 : != new_size)
26778 : {
26779 : Py_XDECREF(resultobj);
26780 : resultobj = NULL;
26781 : PyErr_Format(PyExc_ValueError,
26782 : "Expected buffer of length %zu, got %zi",
26783 : new_size,
26784 : view4.len);
26785 : }
26786 : }
26787 : }
26788 : }
26789 : if (resultobj)
26790 : memcpy(view4.buf, new_data, new_size);
26791 : }
26792 :
26793 :
26794 :
26795 : }
26796 :
26797 : /* Free the temporary wrapper, if any. */
26798 0 : if (wrapper4)
26799 0 : gpgme_data_release(wrapper4);
26800 0 : Py_XDECREF (bytesio4);
26801 : if (have_view4 && view4.buf)
26802 : PyBuffer_Release(&view4);
26803 : }
26804 : return NULL;
26805 : }
26806 :
26807 :
26808 1 : SWIGINTERN PyObject *_wrap_gpgme_op_export_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26809 1 : PyObject *resultobj = 0;
26810 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
26811 : char **arg2 ;
26812 : gpgme_export_mode_t arg3 ;
26813 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
26814 1 : void *argp1 = 0 ;
26815 1 : int res1 = 0 ;
26816 1 : void *vector2 = NULL ;
26817 : size_t size2 ;
26818 1 : PyObject **pyVector2 = NULL ;
26819 : unsigned int val3 ;
26820 1 : int ecode3 = 0 ;
26821 1 : gpgme_data_t wrapper4 = NULL ;
26822 1 : PyObject *bytesio4 = NULL ;
26823 : Py_buffer view4 ;
26824 1 : int have_view4 = 0 ;
26825 1 : PyObject * obj0 = 0 ;
26826 1 : PyObject * obj1 = 0 ;
26827 1 : PyObject * obj2 = 0 ;
26828 1 : PyObject * obj3 = 0 ;
26829 : gpgme_error_t result;
26830 :
26831 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_ext",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26832 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
26833 1 : if (!SWIG_IsOK(res1)) {
26834 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
26835 : }
26836 1 : arg1 = (gpgme_ctx_t)(argp1);
26837 : {
26838 : /* Check if is a list */
26839 1 : if (PyList_Check(obj1)) {
26840 : size_t i, j;
26841 1 : size2 = PyList_Size(obj1);
26842 1 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
26843 1 : pyVector2 = calloc(sizeof *pyVector2, size2);
26844 :
26845 3 : for (i = 0; i < size2; i++) {
26846 2 : PyObject *o = PyList_GetItem(obj1,i);
26847 2 : if (PyUnicode_Check(o))
26848 : {
26849 2 : pyVector2[i] = PyUnicode_AsUTF8String(o);
26850 2 : if (pyVector2[i] == NULL)
26851 : {
26852 0 : free(vector2);
26853 0 : for (j = 0; j < i; j++)
26854 0 : Py_XDECREF(pyVector2[j]);
26855 : return NULL;
26856 : }
26857 2 : arg2[i] = PyBytes_AsString(pyVector2[i]);
26858 : }
26859 0 : else if (PyString_Check(o))
26860 0 : arg2[i] = PyString_AsString(o);
26861 : else {
26862 0 : PyErr_Format(PyExc_TypeError,
26863 : "arg %d: list must contain only str or bytes, got %s "
26864 : "at position %d",
26865 : 2, o->ob_type->tp_name, i);
26866 0 : free(arg2);
26867 0 : return NULL;
26868 : }
26869 : }
26870 1 : arg2[i] = NULL;
26871 : } else {
26872 0 : PyErr_Format(PyExc_TypeError,
26873 : "arg %d: expected a list of str or bytes, got %s",
26874 : 2, obj1->ob_type->tp_name);
26875 0 : return NULL;
26876 : }
26877 : }
26878 2 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
26879 1 : if (!SWIG_IsOK(ecode3)) {
26880 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_ext" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
26881 : }
26882 1 : arg3 = (gpgme_export_mode_t)(val3);
26883 : {
26884 : /* If we create a temporary wrapper4 object, we will store it in
26885 : wrapperN, where N is 4. Here in this fragment, SWIG will
26886 : automatically append 4. */
26887 1 : memset(&view4, 0, sizeof view4);
26888 1 : if (obj3 == Py_None)
26889 0 : arg4 = NULL;
26890 : else {
26891 : PyObject *pypointer;
26892 1 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
26893 : &bytesio4, &view4);
26894 1 : if (pypointer == NULL)
26895 : return NULL;
26896 1 : have_view4 = !! view4.obj;
26897 :
26898 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
26899 :
26900 : /* Following code is from swig's python.swg. */
26901 :
26902 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
26903 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
26904 0 : Py_DECREF(pypointer);
26905 : return NULL;
26906 : }
26907 1 : Py_DECREF(pypointer);
26908 : }
26909 : }
26910 : {
26911 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
26912 1 : result = gpgme_op_export_ext(arg1,(char const *(*))arg2,arg3,arg4);
26913 1 : SWIG_PYTHON_THREAD_END_ALLOW;
26914 : }
26915 : {
26916 1 : resultobj = PyLong_FromLong(result);
26917 : }
26918 : {
26919 : size_t i;
26920 1 : free(vector2);
26921 3 : for (i = 0; i < size2; i++)
26922 2 : Py_XDECREF(pyVector2[i]);
26923 : }
26924 : {
26925 : /* See whether we need to update the Python buffer. */
26926 1 : if (resultobj && wrapper4 && view4.buf)
26927 : {
26928 : int dirty;
26929 0 : char *new_data = NULL;
26930 : size_t new_size;
26931 :
26932 :
26933 0 : new_data = wrapper4->data.mem.buffer;
26934 0 : new_size = wrapper4->data.mem.length;
26935 0 : dirty = new_data != NULL;
26936 :
26937 :
26938 :
26939 :
26940 :
26941 :
26942 :
26943 0 : if (dirty)
26944 : {
26945 : /* The buffer is dirty. */
26946 0 : if (view4.readonly)
26947 : {
26948 0 : Py_XDECREF(resultobj);
26949 0 : resultobj = NULL;
26950 0 : PyErr_SetString(PyExc_ValueError,
26951 : "cannot update read-only buffer");
26952 : }
26953 :
26954 : /* See if we need to truncate the buffer. */
26955 0 : if (resultobj && view4.len != new_size)
26956 : {
26957 0 : if (bytesio4 == NULL)
26958 : {
26959 0 : Py_XDECREF(resultobj);
26960 0 : resultobj = NULL;
26961 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
26962 : }
26963 : else
26964 : {
26965 : PyObject *retval;
26966 0 : PyBuffer_Release(&view4);
26967 : assert(view4.obj == NULL);
26968 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
26969 : "l", (long) new_size);
26970 0 : if (retval == NULL)
26971 : {
26972 0 : Py_XDECREF(resultobj);
26973 : resultobj = NULL;
26974 : }
26975 : else
26976 : {
26977 0 : Py_DECREF(retval);
26978 :
26979 0 : retval = PyObject_CallMethod(bytesio4,
26980 : "getbuffer", NULL);
26981 0 : if (retval == NULL
26982 0 : || PyObject_GetBuffer(retval, &view4,
26983 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
26984 : {
26985 0 : Py_XDECREF(resultobj);
26986 : resultobj = NULL;
26987 : }
26988 :
26989 0 : Py_XDECREF(retval);
26990 :
26991 0 : if (resultobj && view4.len
26992 : != new_size)
26993 : {
26994 0 : Py_XDECREF(resultobj);
26995 0 : resultobj = NULL;
26996 0 : PyErr_Format(PyExc_ValueError,
26997 : "Expected buffer of length %zu, got %zi",
26998 : new_size,
26999 : view4.len);
27000 : }
27001 : }
27002 : }
27003 : }
27004 0 : if (resultobj)
27005 0 : memcpy(view4.buf, new_data, new_size);
27006 : }
27007 :
27008 :
27009 :
27010 : }
27011 :
27012 : /* Free the temporary wrapper, if any. */
27013 1 : if (wrapper4)
27014 0 : gpgme_data_release(wrapper4);
27015 1 : Py_XDECREF (bytesio4);
27016 1 : if (have_view4 && view4.buf)
27017 0 : PyBuffer_Release(&view4);
27018 : }
27019 : return resultobj;
27020 : fail:
27021 : {
27022 : size_t i;
27023 0 : free(vector2);
27024 0 : for (i = 0; i < size2; i++)
27025 0 : Py_XDECREF(pyVector2[i]);
27026 : }
27027 : {
27028 : /* See whether we need to update the Python buffer. */
27029 : if (resultobj && wrapper4 && view4.buf)
27030 : {
27031 : int dirty;
27032 : char *new_data = NULL;
27033 : size_t new_size;
27034 :
27035 :
27036 : new_data = wrapper4->data.mem.buffer;
27037 : new_size = wrapper4->data.mem.length;
27038 : dirty = new_data != NULL;
27039 :
27040 :
27041 :
27042 :
27043 :
27044 :
27045 :
27046 : if (dirty)
27047 : {
27048 : /* The buffer is dirty. */
27049 : if (view4.readonly)
27050 : {
27051 : Py_XDECREF(resultobj);
27052 : resultobj = NULL;
27053 : PyErr_SetString(PyExc_ValueError,
27054 : "cannot update read-only buffer");
27055 : }
27056 :
27057 : /* See if we need to truncate the buffer. */
27058 : if (resultobj && view4.len != new_size)
27059 : {
27060 : if (bytesio4 == NULL)
27061 : {
27062 : Py_XDECREF(resultobj);
27063 : resultobj = NULL;
27064 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27065 : }
27066 : else
27067 : {
27068 : PyObject *retval;
27069 : PyBuffer_Release(&view4);
27070 : assert(view4.obj == NULL);
27071 : retval = PyObject_CallMethod(bytesio4, "truncate",
27072 : "l", (long) new_size);
27073 : if (retval == NULL)
27074 : {
27075 : Py_XDECREF(resultobj);
27076 : resultobj = NULL;
27077 : }
27078 : else
27079 : {
27080 : Py_DECREF(retval);
27081 :
27082 : retval = PyObject_CallMethod(bytesio4,
27083 : "getbuffer", NULL);
27084 : if (retval == NULL
27085 : || PyObject_GetBuffer(retval, &view4,
27086 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27087 : {
27088 : Py_XDECREF(resultobj);
27089 : resultobj = NULL;
27090 : }
27091 :
27092 : Py_XDECREF(retval);
27093 :
27094 : if (resultobj && view4.len
27095 : != new_size)
27096 : {
27097 : Py_XDECREF(resultobj);
27098 : resultobj = NULL;
27099 : PyErr_Format(PyExc_ValueError,
27100 : "Expected buffer of length %zu, got %zi",
27101 : new_size,
27102 : view4.len);
27103 : }
27104 : }
27105 : }
27106 : }
27107 : if (resultobj)
27108 : memcpy(view4.buf, new_data, new_size);
27109 : }
27110 :
27111 :
27112 :
27113 : }
27114 :
27115 : /* Free the temporary wrapper, if any. */
27116 0 : if (wrapper4)
27117 0 : gpgme_data_release(wrapper4);
27118 0 : Py_XDECREF (bytesio4);
27119 : if (have_view4 && view4.buf)
27120 : PyBuffer_Release(&view4);
27121 : }
27122 : return NULL;
27123 : }
27124 :
27125 :
27126 0 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27127 0 : PyObject *resultobj = 0;
27128 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27129 : gpgme_key_t *arg2 ;
27130 : gpgme_export_mode_t arg3 ;
27131 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
27132 0 : void *argp1 = 0 ;
27133 0 : int res1 = 0 ;
27134 : unsigned int val3 ;
27135 0 : int ecode3 = 0 ;
27136 0 : gpgme_data_t wrapper4 = NULL ;
27137 0 : PyObject *bytesio4 = NULL ;
27138 : Py_buffer view4 ;
27139 0 : int have_view4 = 0 ;
27140 0 : PyObject * obj0 = 0 ;
27141 0 : PyObject * obj1 = 0 ;
27142 0 : PyObject * obj2 = 0 ;
27143 0 : PyObject * obj3 = 0 ;
27144 : gpgme_error_t result;
27145 :
27146 : {
27147 0 : arg2 = NULL;
27148 : }
27149 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27150 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27151 0 : if (!SWIG_IsOK(res1)) {
27152 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27153 : }
27154 0 : arg1 = (gpgme_ctx_t)(argp1);
27155 : {
27156 0 : int i, numb = 0;
27157 0 : if (!PySequence_Check(obj1)) {
27158 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
27159 : 2);
27160 0 : return NULL;
27161 : }
27162 0 : if((numb = PySequence_Length(obj1)) != 0) {
27163 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
27164 0 : for(i=0; i<numb; i++) {
27165 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
27166 :
27167 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
27168 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
27169 :
27170 : /* Following code is from swig's python.swg. */
27171 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27172 0 : Py_DECREF(pypointer);
27173 0 : PyErr_Format(PyExc_TypeError,
27174 : "arg %d: list must contain only gpgme_key_ts, got %s "
27175 : "at position %d",
27176 0 : 2, pypointer->ob_type->tp_name, i);
27177 0 : free(arg2);
27178 0 : return NULL;
27179 : }
27180 0 : Py_DECREF(pypointer);
27181 : }
27182 0 : arg2[numb] = NULL;
27183 : }
27184 : }
27185 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
27186 0 : if (!SWIG_IsOK(ecode3)) {
27187 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys_start" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
27188 : }
27189 0 : arg3 = (gpgme_export_mode_t)(val3);
27190 : {
27191 : /* If we create a temporary wrapper4 object, we will store it in
27192 : wrapperN, where N is 4. Here in this fragment, SWIG will
27193 : automatically append 4. */
27194 0 : memset(&view4, 0, sizeof view4);
27195 0 : if (obj3 == Py_None)
27196 0 : arg4 = NULL;
27197 : else {
27198 : PyObject *pypointer;
27199 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
27200 : &bytesio4, &view4);
27201 0 : if (pypointer == NULL)
27202 : return NULL;
27203 0 : have_view4 = !! view4.obj;
27204 :
27205 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
27206 :
27207 : /* Following code is from swig's python.swg. */
27208 :
27209 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
27210 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27211 0 : Py_DECREF(pypointer);
27212 : return NULL;
27213 : }
27214 0 : Py_DECREF(pypointer);
27215 : }
27216 : }
27217 : {
27218 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27219 0 : result = gpgme_op_export_keys_start(arg1,arg2,arg3,arg4);
27220 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27221 : }
27222 : {
27223 0 : resultobj = PyLong_FromLong(result);
27224 : }
27225 : {
27226 0 : if (arg2) free(arg2);
27227 : }
27228 : {
27229 : /* See whether we need to update the Python buffer. */
27230 0 : if (resultobj && wrapper4 && view4.buf)
27231 : {
27232 : int dirty;
27233 0 : char *new_data = NULL;
27234 : size_t new_size;
27235 :
27236 :
27237 0 : new_data = wrapper4->data.mem.buffer;
27238 0 : new_size = wrapper4->data.mem.length;
27239 0 : dirty = new_data != NULL;
27240 :
27241 :
27242 :
27243 :
27244 :
27245 :
27246 :
27247 0 : if (dirty)
27248 : {
27249 : /* The buffer is dirty. */
27250 0 : if (view4.readonly)
27251 : {
27252 0 : Py_XDECREF(resultobj);
27253 0 : resultobj = NULL;
27254 0 : PyErr_SetString(PyExc_ValueError,
27255 : "cannot update read-only buffer");
27256 : }
27257 :
27258 : /* See if we need to truncate the buffer. */
27259 0 : if (resultobj && view4.len != new_size)
27260 : {
27261 0 : if (bytesio4 == NULL)
27262 : {
27263 0 : Py_XDECREF(resultobj);
27264 0 : resultobj = NULL;
27265 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27266 : }
27267 : else
27268 : {
27269 : PyObject *retval;
27270 0 : PyBuffer_Release(&view4);
27271 : assert(view4.obj == NULL);
27272 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
27273 : "l", (long) new_size);
27274 0 : if (retval == NULL)
27275 : {
27276 0 : Py_XDECREF(resultobj);
27277 : resultobj = NULL;
27278 : }
27279 : else
27280 : {
27281 0 : Py_DECREF(retval);
27282 :
27283 0 : retval = PyObject_CallMethod(bytesio4,
27284 : "getbuffer", NULL);
27285 0 : if (retval == NULL
27286 0 : || PyObject_GetBuffer(retval, &view4,
27287 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27288 : {
27289 0 : Py_XDECREF(resultobj);
27290 : resultobj = NULL;
27291 : }
27292 :
27293 0 : Py_XDECREF(retval);
27294 :
27295 0 : if (resultobj && view4.len
27296 : != new_size)
27297 : {
27298 0 : Py_XDECREF(resultobj);
27299 0 : resultobj = NULL;
27300 0 : PyErr_Format(PyExc_ValueError,
27301 : "Expected buffer of length %zu, got %zi",
27302 : new_size,
27303 : view4.len);
27304 : }
27305 : }
27306 : }
27307 : }
27308 0 : if (resultobj)
27309 0 : memcpy(view4.buf, new_data, new_size);
27310 : }
27311 :
27312 :
27313 :
27314 : }
27315 :
27316 : /* Free the temporary wrapper, if any. */
27317 0 : if (wrapper4)
27318 0 : gpgme_data_release(wrapper4);
27319 0 : Py_XDECREF (bytesio4);
27320 0 : if (have_view4 && view4.buf)
27321 0 : PyBuffer_Release(&view4);
27322 : }
27323 : return resultobj;
27324 : fail:
27325 : {
27326 0 : if (arg2) free(arg2);
27327 : }
27328 : {
27329 : /* See whether we need to update the Python buffer. */
27330 : if (resultobj && wrapper4 && view4.buf)
27331 : {
27332 : int dirty;
27333 : char *new_data = NULL;
27334 : size_t new_size;
27335 :
27336 :
27337 : new_data = wrapper4->data.mem.buffer;
27338 : new_size = wrapper4->data.mem.length;
27339 : dirty = new_data != NULL;
27340 :
27341 :
27342 :
27343 :
27344 :
27345 :
27346 :
27347 : if (dirty)
27348 : {
27349 : /* The buffer is dirty. */
27350 : if (view4.readonly)
27351 : {
27352 : Py_XDECREF(resultobj);
27353 : resultobj = NULL;
27354 : PyErr_SetString(PyExc_ValueError,
27355 : "cannot update read-only buffer");
27356 : }
27357 :
27358 : /* See if we need to truncate the buffer. */
27359 : if (resultobj && view4.len != new_size)
27360 : {
27361 : if (bytesio4 == NULL)
27362 : {
27363 : Py_XDECREF(resultobj);
27364 : resultobj = NULL;
27365 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27366 : }
27367 : else
27368 : {
27369 : PyObject *retval;
27370 : PyBuffer_Release(&view4);
27371 : assert(view4.obj == NULL);
27372 : retval = PyObject_CallMethod(bytesio4, "truncate",
27373 : "l", (long) new_size);
27374 : if (retval == NULL)
27375 : {
27376 : Py_XDECREF(resultobj);
27377 : resultobj = NULL;
27378 : }
27379 : else
27380 : {
27381 : Py_DECREF(retval);
27382 :
27383 : retval = PyObject_CallMethod(bytesio4,
27384 : "getbuffer", NULL);
27385 : if (retval == NULL
27386 : || PyObject_GetBuffer(retval, &view4,
27387 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27388 : {
27389 : Py_XDECREF(resultobj);
27390 : resultobj = NULL;
27391 : }
27392 :
27393 : Py_XDECREF(retval);
27394 :
27395 : if (resultobj && view4.len
27396 : != new_size)
27397 : {
27398 : Py_XDECREF(resultobj);
27399 : resultobj = NULL;
27400 : PyErr_Format(PyExc_ValueError,
27401 : "Expected buffer of length %zu, got %zi",
27402 : new_size,
27403 : view4.len);
27404 : }
27405 : }
27406 : }
27407 : }
27408 : if (resultobj)
27409 : memcpy(view4.buf, new_data, new_size);
27410 : }
27411 :
27412 :
27413 :
27414 : }
27415 :
27416 : /* Free the temporary wrapper, if any. */
27417 0 : if (wrapper4)
27418 0 : gpgme_data_release(wrapper4);
27419 0 : Py_XDECREF (bytesio4);
27420 : if (have_view4 && view4.buf)
27421 : PyBuffer_Release(&view4);
27422 : }
27423 : return NULL;
27424 : }
27425 :
27426 :
27427 1 : SWIGINTERN PyObject *_wrap_gpgme_op_export_keys(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27428 1 : PyObject *resultobj = 0;
27429 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
27430 : gpgme_key_t *arg2 ;
27431 : gpgme_export_mode_t arg3 ;
27432 1 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
27433 1 : void *argp1 = 0 ;
27434 1 : int res1 = 0 ;
27435 : unsigned int val3 ;
27436 1 : int ecode3 = 0 ;
27437 1 : gpgme_data_t wrapper4 = NULL ;
27438 1 : PyObject *bytesio4 = NULL ;
27439 : Py_buffer view4 ;
27440 1 : int have_view4 = 0 ;
27441 1 : PyObject * obj0 = 0 ;
27442 1 : PyObject * obj1 = 0 ;
27443 1 : PyObject * obj2 = 0 ;
27444 1 : PyObject * obj3 = 0 ;
27445 : gpgme_error_t result;
27446 :
27447 : {
27448 1 : arg2 = NULL;
27449 : }
27450 1 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_export_keys",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27451 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
27452 1 : if (!SWIG_IsOK(res1)) {
27453 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_export_keys" "', argument " "1"" of type '" "gpgme_ctx_t""'");
27454 : }
27455 1 : arg1 = (gpgme_ctx_t)(argp1);
27456 : {
27457 1 : int i, numb = 0;
27458 1 : if (!PySequence_Check(obj1)) {
27459 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
27460 : 2);
27461 0 : return NULL;
27462 : }
27463 1 : if((numb = PySequence_Length(obj1)) != 0) {
27464 1 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
27465 3 : for(i=0; i<numb; i++) {
27466 2 : PyObject *pypointer = PySequence_GetItem(obj1, i);
27467 :
27468 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
27469 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
27470 :
27471 : /* Following code is from swig's python.swg. */
27472 2 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27473 0 : Py_DECREF(pypointer);
27474 0 : PyErr_Format(PyExc_TypeError,
27475 : "arg %d: list must contain only gpgme_key_ts, got %s "
27476 : "at position %d",
27477 0 : 2, pypointer->ob_type->tp_name, i);
27478 0 : free(arg2);
27479 0 : return NULL;
27480 : }
27481 2 : Py_DECREF(pypointer);
27482 : }
27483 1 : arg2[numb] = NULL;
27484 : }
27485 : }
27486 2 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
27487 1 : if (!SWIG_IsOK(ecode3)) {
27488 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_export_keys" "', argument " "3"" of type '" "gpgme_export_mode_t""'");
27489 : }
27490 1 : arg3 = (gpgme_export_mode_t)(val3);
27491 : {
27492 : /* If we create a temporary wrapper4 object, we will store it in
27493 : wrapperN, where N is 4. Here in this fragment, SWIG will
27494 : automatically append 4. */
27495 1 : memset(&view4, 0, sizeof view4);
27496 1 : if (obj3 == Py_None)
27497 0 : arg4 = NULL;
27498 : else {
27499 : PyObject *pypointer;
27500 1 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
27501 : &bytesio4, &view4);
27502 1 : if (pypointer == NULL)
27503 : return NULL;
27504 1 : have_view4 = !! view4.obj;
27505 :
27506 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
27507 :
27508 : /* Following code is from swig's python.swg. */
27509 :
27510 1 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
27511 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
27512 0 : Py_DECREF(pypointer);
27513 : return NULL;
27514 : }
27515 1 : Py_DECREF(pypointer);
27516 : }
27517 : }
27518 : {
27519 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27520 1 : result = gpgme_op_export_keys(arg1,arg2,arg3,arg4);
27521 1 : SWIG_PYTHON_THREAD_END_ALLOW;
27522 : }
27523 : {
27524 1 : resultobj = PyLong_FromLong(result);
27525 : }
27526 : {
27527 1 : if (arg2) free(arg2);
27528 : }
27529 : {
27530 : /* See whether we need to update the Python buffer. */
27531 1 : if (resultobj && wrapper4 && view4.buf)
27532 : {
27533 : int dirty;
27534 0 : char *new_data = NULL;
27535 : size_t new_size;
27536 :
27537 :
27538 0 : new_data = wrapper4->data.mem.buffer;
27539 0 : new_size = wrapper4->data.mem.length;
27540 0 : dirty = new_data != NULL;
27541 :
27542 :
27543 :
27544 :
27545 :
27546 :
27547 :
27548 0 : if (dirty)
27549 : {
27550 : /* The buffer is dirty. */
27551 0 : if (view4.readonly)
27552 : {
27553 0 : Py_XDECREF(resultobj);
27554 0 : resultobj = NULL;
27555 0 : PyErr_SetString(PyExc_ValueError,
27556 : "cannot update read-only buffer");
27557 : }
27558 :
27559 : /* See if we need to truncate the buffer. */
27560 0 : if (resultobj && view4.len != new_size)
27561 : {
27562 0 : if (bytesio4 == NULL)
27563 : {
27564 0 : Py_XDECREF(resultobj);
27565 0 : resultobj = NULL;
27566 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27567 : }
27568 : else
27569 : {
27570 : PyObject *retval;
27571 0 : PyBuffer_Release(&view4);
27572 : assert(view4.obj == NULL);
27573 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
27574 : "l", (long) new_size);
27575 0 : if (retval == NULL)
27576 : {
27577 0 : Py_XDECREF(resultobj);
27578 : resultobj = NULL;
27579 : }
27580 : else
27581 : {
27582 0 : Py_DECREF(retval);
27583 :
27584 0 : retval = PyObject_CallMethod(bytesio4,
27585 : "getbuffer", NULL);
27586 0 : if (retval == NULL
27587 0 : || PyObject_GetBuffer(retval, &view4,
27588 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27589 : {
27590 0 : Py_XDECREF(resultobj);
27591 : resultobj = NULL;
27592 : }
27593 :
27594 0 : Py_XDECREF(retval);
27595 :
27596 0 : if (resultobj && view4.len
27597 : != new_size)
27598 : {
27599 0 : Py_XDECREF(resultobj);
27600 0 : resultobj = NULL;
27601 0 : PyErr_Format(PyExc_ValueError,
27602 : "Expected buffer of length %zu, got %zi",
27603 : new_size,
27604 : view4.len);
27605 : }
27606 : }
27607 : }
27608 : }
27609 0 : if (resultobj)
27610 0 : memcpy(view4.buf, new_data, new_size);
27611 : }
27612 :
27613 :
27614 :
27615 : }
27616 :
27617 : /* Free the temporary wrapper, if any. */
27618 1 : if (wrapper4)
27619 0 : gpgme_data_release(wrapper4);
27620 1 : Py_XDECREF (bytesio4);
27621 1 : if (have_view4 && view4.buf)
27622 0 : PyBuffer_Release(&view4);
27623 : }
27624 : return resultobj;
27625 : fail:
27626 : {
27627 0 : if (arg2) free(arg2);
27628 : }
27629 : {
27630 : /* See whether we need to update the Python buffer. */
27631 : if (resultobj && wrapper4 && view4.buf)
27632 : {
27633 : int dirty;
27634 : char *new_data = NULL;
27635 : size_t new_size;
27636 :
27637 :
27638 : new_data = wrapper4->data.mem.buffer;
27639 : new_size = wrapper4->data.mem.length;
27640 : dirty = new_data != NULL;
27641 :
27642 :
27643 :
27644 :
27645 :
27646 :
27647 :
27648 : if (dirty)
27649 : {
27650 : /* The buffer is dirty. */
27651 : if (view4.readonly)
27652 : {
27653 : Py_XDECREF(resultobj);
27654 : resultobj = NULL;
27655 : PyErr_SetString(PyExc_ValueError,
27656 : "cannot update read-only buffer");
27657 : }
27658 :
27659 : /* See if we need to truncate the buffer. */
27660 : if (resultobj && view4.len != new_size)
27661 : {
27662 : if (bytesio4 == NULL)
27663 : {
27664 : Py_XDECREF(resultobj);
27665 : resultobj = NULL;
27666 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
27667 : }
27668 : else
27669 : {
27670 : PyObject *retval;
27671 : PyBuffer_Release(&view4);
27672 : assert(view4.obj == NULL);
27673 : retval = PyObject_CallMethod(bytesio4, "truncate",
27674 : "l", (long) new_size);
27675 : if (retval == NULL)
27676 : {
27677 : Py_XDECREF(resultobj);
27678 : resultobj = NULL;
27679 : }
27680 : else
27681 : {
27682 : Py_DECREF(retval);
27683 :
27684 : retval = PyObject_CallMethod(bytesio4,
27685 : "getbuffer", NULL);
27686 : if (retval == NULL
27687 : || PyObject_GetBuffer(retval, &view4,
27688 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
27689 : {
27690 : Py_XDECREF(resultobj);
27691 : resultobj = NULL;
27692 : }
27693 :
27694 : Py_XDECREF(retval);
27695 :
27696 : if (resultobj && view4.len
27697 : != new_size)
27698 : {
27699 : Py_XDECREF(resultobj);
27700 : resultobj = NULL;
27701 : PyErr_Format(PyExc_ValueError,
27702 : "Expected buffer of length %zu, got %zi",
27703 : new_size,
27704 : view4.len);
27705 : }
27706 : }
27707 : }
27708 : }
27709 : if (resultobj)
27710 : memcpy(view4.buf, new_data, new_size);
27711 : }
27712 :
27713 :
27714 :
27715 : }
27716 :
27717 : /* Free the temporary wrapper, if any. */
27718 0 : if (wrapper4)
27719 0 : gpgme_data_release(wrapper4);
27720 0 : Py_XDECREF (bytesio4);
27721 : if (have_view4 && view4.buf)
27722 : PyBuffer_Release(&view4);
27723 : }
27724 : return NULL;
27725 : }
27726 :
27727 :
27728 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27729 0 : PyObject *resultobj = 0;
27730 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27731 : unsigned int arg2 ;
27732 0 : void *argp1 = 0 ;
27733 0 : int res1 = 0 ;
27734 : unsigned int val2 ;
27735 0 : int ecode2 = 0 ;
27736 0 : PyObject * obj0 = 0 ;
27737 0 : PyObject * obj1 = 0 ;
27738 :
27739 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_primary_set",&obj0,&obj1)) SWIG_fail;
27740 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27741 0 : if (!SWIG_IsOK(res1)) {
27742 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27743 : }
27744 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27745 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27746 0 : if (!SWIG_IsOK(ecode2)) {
27747 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_primary_set" "', argument " "2"" of type '" "unsigned int""'");
27748 : }
27749 0 : arg2 = (unsigned int)(val2);
27750 : {
27751 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27752 0 : if (arg1) (arg1)->primary = arg2;
27753 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27754 : }
27755 0 : resultobj = SWIG_Py_Void();
27756 0 : return resultobj;
27757 : fail:
27758 : return NULL;
27759 : }
27760 :
27761 :
27762 72 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_primary_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27763 72 : PyObject *resultobj = 0;
27764 72 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27765 72 : void *argp1 = 0 ;
27766 72 : int res1 = 0 ;
27767 72 : PyObject * obj0 = 0 ;
27768 : unsigned int result;
27769 :
27770 72 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_primary_get",&obj0)) SWIG_fail;
27771 72 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27772 72 : if (!SWIG_IsOK(res1)) {
27773 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_primary_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27774 : }
27775 72 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27776 : {
27777 72 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27778 72 : result = (unsigned int) ((arg1)->primary);
27779 72 : SWIG_PYTHON_THREAD_END_ALLOW;
27780 : }
27781 72 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27782 72 : return resultobj;
27783 : fail:
27784 : return NULL;
27785 : }
27786 :
27787 :
27788 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27789 0 : PyObject *resultobj = 0;
27790 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27791 : unsigned int arg2 ;
27792 0 : void *argp1 = 0 ;
27793 0 : int res1 = 0 ;
27794 : unsigned int val2 ;
27795 0 : int ecode2 = 0 ;
27796 0 : PyObject * obj0 = 0 ;
27797 0 : PyObject * obj1 = 0 ;
27798 :
27799 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_sub_set",&obj0,&obj1)) SWIG_fail;
27800 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27801 0 : if (!SWIG_IsOK(res1)) {
27802 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27803 : }
27804 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27805 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27806 0 : if (!SWIG_IsOK(ecode2)) {
27807 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_sub_set" "', argument " "2"" of type '" "unsigned int""'");
27808 : }
27809 0 : arg2 = (unsigned int)(val2);
27810 : {
27811 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27812 0 : if (arg1) (arg1)->sub = arg2;
27813 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27814 : }
27815 0 : resultobj = SWIG_Py_Void();
27816 0 : return resultobj;
27817 : fail:
27818 : return NULL;
27819 : }
27820 :
27821 :
27822 72 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_sub_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27823 72 : PyObject *resultobj = 0;
27824 72 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27825 72 : void *argp1 = 0 ;
27826 72 : int res1 = 0 ;
27827 72 : PyObject * obj0 = 0 ;
27828 : unsigned int result;
27829 :
27830 72 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_sub_get",&obj0)) SWIG_fail;
27831 72 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27832 72 : if (!SWIG_IsOK(res1)) {
27833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_sub_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27834 : }
27835 72 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27836 : {
27837 72 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27838 72 : result = (unsigned int) ((arg1)->sub);
27839 72 : SWIG_PYTHON_THREAD_END_ALLOW;
27840 : }
27841 72 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27842 72 : return resultobj;
27843 : fail:
27844 : return NULL;
27845 : }
27846 :
27847 :
27848 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_uid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27849 0 : PyObject *resultobj = 0;
27850 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27851 : unsigned int arg2 ;
27852 0 : void *argp1 = 0 ;
27853 0 : int res1 = 0 ;
27854 : unsigned int val2 ;
27855 0 : int ecode2 = 0 ;
27856 0 : PyObject * obj0 = 0 ;
27857 0 : PyObject * obj1 = 0 ;
27858 :
27859 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_uid_set",&obj0,&obj1)) SWIG_fail;
27860 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27861 0 : if (!SWIG_IsOK(res1)) {
27862 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_uid_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27863 : }
27864 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27865 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27866 0 : if (!SWIG_IsOK(ecode2)) {
27867 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result_uid_set" "', argument " "2"" of type '" "unsigned int""'");
27868 : }
27869 0 : arg2 = (unsigned int)(val2);
27870 : {
27871 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27872 0 : if (arg1) (arg1)->uid = arg2;
27873 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27874 : }
27875 0 : resultobj = SWIG_Py_Void();
27876 0 : return resultobj;
27877 : fail:
27878 : return NULL;
27879 : }
27880 :
27881 :
27882 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_uid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27883 36 : PyObject *resultobj = 0;
27884 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27885 36 : void *argp1 = 0 ;
27886 36 : int res1 = 0 ;
27887 36 : PyObject * obj0 = 0 ;
27888 : unsigned int result;
27889 :
27890 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_uid_get",&obj0)) SWIG_fail;
27891 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27892 36 : if (!SWIG_IsOK(res1)) {
27893 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_uid_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27894 : }
27895 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27896 : {
27897 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27898 36 : result = (unsigned int) ((arg1)->uid);
27899 36 : SWIG_PYTHON_THREAD_END_ALLOW;
27900 : }
27901 36 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27902 36 : return resultobj;
27903 : fail:
27904 : return NULL;
27905 : }
27906 :
27907 :
27908 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27909 0 : PyObject *resultobj = 0;
27910 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27911 : unsigned int arg2 ;
27912 0 : void *argp1 = 0 ;
27913 0 : int res1 = 0 ;
27914 : unsigned int val2 ;
27915 0 : int ecode2 = 0 ;
27916 0 : PyObject * obj0 = 0 ;
27917 0 : PyObject * obj1 = 0 ;
27918 :
27919 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result__unused_set",&obj0,&obj1)) SWIG_fail;
27920 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27921 0 : if (!SWIG_IsOK(res1)) {
27922 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27923 : }
27924 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27925 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
27926 0 : if (!SWIG_IsOK(ecode2)) {
27927 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_genkey_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
27928 : }
27929 0 : arg2 = (unsigned int)(val2);
27930 : {
27931 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27932 0 : if (arg1) (arg1)->_unused = arg2;
27933 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27934 : }
27935 0 : resultobj = SWIG_Py_Void();
27936 0 : return resultobj;
27937 : fail:
27938 : return NULL;
27939 : }
27940 :
27941 :
27942 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27943 0 : PyObject *resultobj = 0;
27944 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27945 0 : void *argp1 = 0 ;
27946 0 : int res1 = 0 ;
27947 0 : PyObject * obj0 = 0 ;
27948 : unsigned int result;
27949 :
27950 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result__unused_get",&obj0)) SWIG_fail;
27951 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27952 0 : if (!SWIG_IsOK(res1)) {
27953 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27954 : }
27955 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27956 : {
27957 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27958 0 : result = (unsigned int) ((arg1)->_unused);
27959 0 : SWIG_PYTHON_THREAD_END_ALLOW;
27960 : }
27961 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
27962 0 : return resultobj;
27963 : fail:
27964 : return NULL;
27965 : }
27966 :
27967 :
27968 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27969 0 : PyObject *resultobj = 0;
27970 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
27971 0 : char *arg2 = (char *) 0 ;
27972 0 : void *argp1 = 0 ;
27973 0 : int res1 = 0 ;
27974 : int res2 ;
27975 0 : char *buf2 = 0 ;
27976 0 : int alloc2 = 0 ;
27977 0 : PyObject * obj0 = 0 ;
27978 0 : PyObject * obj1 = 0 ;
27979 :
27980 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_fpr_set",&obj0,&obj1)) SWIG_fail;
27981 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
27982 0 : if (!SWIG_IsOK(res1)) {
27983 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
27984 : }
27985 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
27986 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
27987 0 : if (!SWIG_IsOK(res2)) {
27988 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_genkey_result_fpr_set" "', argument " "2"" of type '" "char *""'");
27989 : }
27990 0 : arg2 = (char *)(buf2);
27991 : {
27992 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
27993 0 : if (arg1->fpr) free((char*)arg1->fpr);
27994 0 : if (arg2) {
27995 0 : size_t size = strlen((const char *)(arg2)) + 1;
27996 0 : arg1->fpr = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
27997 : } else {
27998 0 : arg1->fpr = 0;
27999 : }
28000 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28001 : }
28002 0 : resultobj = SWIG_Py_Void();
28003 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28004 : return resultobj;
28005 : fail:
28006 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
28007 : return NULL;
28008 : }
28009 :
28010 :
28011 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_fpr_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28012 36 : PyObject *resultobj = 0;
28013 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28014 36 : void *argp1 = 0 ;
28015 36 : int res1 = 0 ;
28016 36 : PyObject * obj0 = 0 ;
28017 36 : char *result = 0 ;
28018 :
28019 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_fpr_get",&obj0)) SWIG_fail;
28020 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
28021 36 : if (!SWIG_IsOK(res1)) {
28022 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_fpr_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28023 : }
28024 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28025 : {
28026 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28027 36 : result = (char *) ((arg1)->fpr);
28028 36 : SWIG_PYTHON_THREAD_END_ALLOW;
28029 : }
28030 36 : resultobj = SWIG_FromCharPtr((const char *)result);
28031 36 : return resultobj;
28032 : fail:
28033 : return NULL;
28034 : }
28035 :
28036 :
28037 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_pubkey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28038 0 : PyObject *resultobj = 0;
28039 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28040 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
28041 0 : void *argp1 = 0 ;
28042 0 : int res1 = 0 ;
28043 0 : gpgme_data_t wrapper2 = NULL ;
28044 0 : PyObject *bytesio2 = NULL ;
28045 : Py_buffer view2 ;
28046 0 : int have_view2 = 0 ;
28047 0 : PyObject * obj0 = 0 ;
28048 0 : PyObject * obj1 = 0 ;
28049 :
28050 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_pubkey_set",&obj0,&obj1)) SWIG_fail;
28051 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
28052 0 : if (!SWIG_IsOK(res1)) {
28053 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_pubkey_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28054 : }
28055 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28056 : {
28057 : /* If we create a temporary wrapper2 object, we will store it in
28058 : wrapperN, where N is 2. Here in this fragment, SWIG will
28059 : automatically append 2. */
28060 0 : memset(&view2, 0, sizeof view2);
28061 0 : if (obj1 == Py_None)
28062 0 : arg2 = NULL;
28063 : else {
28064 : PyObject *pypointer;
28065 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
28066 : &bytesio2, &view2);
28067 0 : if (pypointer == NULL)
28068 : return NULL;
28069 0 : have_view2 = !! view2.obj;
28070 :
28071 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
28072 :
28073 : /* Following code is from swig's python.swg. */
28074 :
28075 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
28076 : SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN )) == -1) {
28077 0 : Py_DECREF(pypointer);
28078 : return NULL;
28079 : }
28080 0 : Py_DECREF(pypointer);
28081 : }
28082 : }
28083 : {
28084 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28085 0 : if (arg1) (arg1)->pubkey = arg2;
28086 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28087 : }
28088 0 : resultobj = SWIG_Py_Void();
28089 : {
28090 : /* See whether we need to update the Python buffer. */
28091 0 : if (resultobj && wrapper2 && view2.buf)
28092 : {
28093 : int dirty;
28094 0 : char *new_data = NULL;
28095 : size_t new_size;
28096 :
28097 :
28098 0 : new_data = wrapper2->data.mem.buffer;
28099 0 : new_size = wrapper2->data.mem.length;
28100 0 : dirty = new_data != NULL;
28101 :
28102 :
28103 :
28104 :
28105 :
28106 :
28107 :
28108 0 : if (dirty)
28109 : {
28110 : /* The buffer is dirty. */
28111 0 : if (view2.readonly)
28112 : {
28113 0 : Py_XDECREF(resultobj);
28114 0 : resultobj = NULL;
28115 0 : PyErr_SetString(PyExc_ValueError,
28116 : "cannot update read-only buffer");
28117 : }
28118 :
28119 : /* See if we need to truncate the buffer. */
28120 0 : if (resultobj && view2.len != new_size)
28121 : {
28122 0 : if (bytesio2 == NULL)
28123 : {
28124 0 : Py_XDECREF(resultobj);
28125 0 : resultobj = NULL;
28126 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28127 : }
28128 : else
28129 : {
28130 : PyObject *retval;
28131 0 : PyBuffer_Release(&view2);
28132 : assert(view2.obj == NULL);
28133 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
28134 : "l", (long) new_size);
28135 0 : if (retval == NULL)
28136 : {
28137 0 : Py_XDECREF(resultobj);
28138 : resultobj = NULL;
28139 : }
28140 : else
28141 : {
28142 0 : Py_DECREF(retval);
28143 :
28144 0 : retval = PyObject_CallMethod(bytesio2,
28145 : "getbuffer", NULL);
28146 0 : if (retval == NULL
28147 0 : || PyObject_GetBuffer(retval, &view2,
28148 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28149 : {
28150 0 : Py_XDECREF(resultobj);
28151 : resultobj = NULL;
28152 : }
28153 :
28154 0 : Py_XDECREF(retval);
28155 :
28156 0 : if (resultobj && view2.len
28157 : != new_size)
28158 : {
28159 0 : Py_XDECREF(resultobj);
28160 0 : resultobj = NULL;
28161 0 : PyErr_Format(PyExc_ValueError,
28162 : "Expected buffer of length %zu, got %zi",
28163 : new_size,
28164 : view2.len);
28165 : }
28166 : }
28167 : }
28168 : }
28169 0 : if (resultobj)
28170 0 : memcpy(view2.buf, new_data, new_size);
28171 : }
28172 :
28173 :
28174 :
28175 : }
28176 :
28177 : /* Free the temporary wrapper, if any. */
28178 0 : if (wrapper2)
28179 0 : gpgme_data_release(wrapper2);
28180 0 : Py_XDECREF (bytesio2);
28181 0 : if (have_view2 && view2.buf)
28182 0 : PyBuffer_Release(&view2);
28183 : }
28184 : return resultobj;
28185 : fail:
28186 : {
28187 : /* See whether we need to update the Python buffer. */
28188 : if (resultobj && wrapper2 && view2.buf)
28189 : {
28190 : int dirty;
28191 : char *new_data = NULL;
28192 : size_t new_size;
28193 :
28194 :
28195 : new_data = wrapper2->data.mem.buffer;
28196 : new_size = wrapper2->data.mem.length;
28197 : dirty = new_data != NULL;
28198 :
28199 :
28200 :
28201 :
28202 :
28203 :
28204 :
28205 : if (dirty)
28206 : {
28207 : /* The buffer is dirty. */
28208 : if (view2.readonly)
28209 : {
28210 : Py_XDECREF(resultobj);
28211 : resultobj = NULL;
28212 : PyErr_SetString(PyExc_ValueError,
28213 : "cannot update read-only buffer");
28214 : }
28215 :
28216 : /* See if we need to truncate the buffer. */
28217 : if (resultobj && view2.len != new_size)
28218 : {
28219 : if (bytesio2 == NULL)
28220 : {
28221 : Py_XDECREF(resultobj);
28222 : resultobj = NULL;
28223 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28224 : }
28225 : else
28226 : {
28227 : PyObject *retval;
28228 : PyBuffer_Release(&view2);
28229 : assert(view2.obj == NULL);
28230 : retval = PyObject_CallMethod(bytesio2, "truncate",
28231 : "l", (long) new_size);
28232 : if (retval == NULL)
28233 : {
28234 : Py_XDECREF(resultobj);
28235 : resultobj = NULL;
28236 : }
28237 : else
28238 : {
28239 : Py_DECREF(retval);
28240 :
28241 : retval = PyObject_CallMethod(bytesio2,
28242 : "getbuffer", NULL);
28243 : if (retval == NULL
28244 : || PyObject_GetBuffer(retval, &view2,
28245 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28246 : {
28247 : Py_XDECREF(resultobj);
28248 : resultobj = NULL;
28249 : }
28250 :
28251 : Py_XDECREF(retval);
28252 :
28253 : if (resultobj && view2.len
28254 : != new_size)
28255 : {
28256 : Py_XDECREF(resultobj);
28257 : resultobj = NULL;
28258 : PyErr_Format(PyExc_ValueError,
28259 : "Expected buffer of length %zu, got %zi",
28260 : new_size,
28261 : view2.len);
28262 : }
28263 : }
28264 : }
28265 : }
28266 : if (resultobj)
28267 : memcpy(view2.buf, new_data, new_size);
28268 : }
28269 :
28270 :
28271 :
28272 : }
28273 :
28274 : /* Free the temporary wrapper, if any. */
28275 0 : if (wrapper2)
28276 0 : gpgme_data_release(wrapper2);
28277 0 : Py_XDECREF (bytesio2);
28278 : if (have_view2 && view2.buf)
28279 : PyBuffer_Release(&view2);
28280 : }
28281 : return NULL;
28282 : }
28283 :
28284 :
28285 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_pubkey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28286 36 : PyObject *resultobj = 0;
28287 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28288 36 : void *argp1 = 0 ;
28289 36 : int res1 = 0 ;
28290 36 : PyObject * obj0 = 0 ;
28291 : gpgme_data_t result;
28292 :
28293 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_pubkey_get",&obj0)) SWIG_fail;
28294 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
28295 36 : if (!SWIG_IsOK(res1)) {
28296 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_pubkey_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28297 : }
28298 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28299 : {
28300 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28301 36 : result = (gpgme_data_t) ((arg1)->pubkey);
28302 36 : SWIG_PYTHON_THREAD_END_ALLOW;
28303 : }
28304 36 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
28305 36 : return resultobj;
28306 : fail:
28307 : return NULL;
28308 : }
28309 :
28310 :
28311 0 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_seckey_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28312 0 : PyObject *resultobj = 0;
28313 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28314 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
28315 0 : void *argp1 = 0 ;
28316 0 : int res1 = 0 ;
28317 0 : gpgme_data_t wrapper2 = NULL ;
28318 0 : PyObject *bytesio2 = NULL ;
28319 : Py_buffer view2 ;
28320 0 : int have_view2 = 0 ;
28321 0 : PyObject * obj0 = 0 ;
28322 0 : PyObject * obj1 = 0 ;
28323 :
28324 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_genkey_result_seckey_set",&obj0,&obj1)) SWIG_fail;
28325 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
28326 0 : if (!SWIG_IsOK(res1)) {
28327 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_seckey_set" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28328 : }
28329 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28330 : {
28331 : /* If we create a temporary wrapper2 object, we will store it in
28332 : wrapperN, where N is 2. Here in this fragment, SWIG will
28333 : automatically append 2. */
28334 0 : memset(&view2, 0, sizeof view2);
28335 0 : if (obj1 == Py_None)
28336 0 : arg2 = NULL;
28337 : else {
28338 : PyObject *pypointer;
28339 0 : pypointer = _gpg_obj2gpgme_data_t(obj1, 2, &wrapper2,
28340 : &bytesio2, &view2);
28341 0 : if (pypointer == NULL)
28342 : return NULL;
28343 0 : have_view2 = !! view2.obj;
28344 :
28345 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_gpgme_data */
28346 :
28347 : /* Following code is from swig's python.swg. */
28348 :
28349 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2, SWIGTYPE_p_gpgme_data,
28350 : SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN )) == -1) {
28351 0 : Py_DECREF(pypointer);
28352 : return NULL;
28353 : }
28354 0 : Py_DECREF(pypointer);
28355 : }
28356 : }
28357 : {
28358 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28359 0 : if (arg1) (arg1)->seckey = arg2;
28360 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28361 : }
28362 0 : resultobj = SWIG_Py_Void();
28363 : {
28364 : /* See whether we need to update the Python buffer. */
28365 0 : if (resultobj && wrapper2 && view2.buf)
28366 : {
28367 : int dirty;
28368 0 : char *new_data = NULL;
28369 : size_t new_size;
28370 :
28371 :
28372 0 : new_data = wrapper2->data.mem.buffer;
28373 0 : new_size = wrapper2->data.mem.length;
28374 0 : dirty = new_data != NULL;
28375 :
28376 :
28377 :
28378 :
28379 :
28380 :
28381 :
28382 0 : if (dirty)
28383 : {
28384 : /* The buffer is dirty. */
28385 0 : if (view2.readonly)
28386 : {
28387 0 : Py_XDECREF(resultobj);
28388 0 : resultobj = NULL;
28389 0 : PyErr_SetString(PyExc_ValueError,
28390 : "cannot update read-only buffer");
28391 : }
28392 :
28393 : /* See if we need to truncate the buffer. */
28394 0 : if (resultobj && view2.len != new_size)
28395 : {
28396 0 : if (bytesio2 == NULL)
28397 : {
28398 0 : Py_XDECREF(resultobj);
28399 0 : resultobj = NULL;
28400 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28401 : }
28402 : else
28403 : {
28404 : PyObject *retval;
28405 0 : PyBuffer_Release(&view2);
28406 : assert(view2.obj == NULL);
28407 0 : retval = PyObject_CallMethod(bytesio2, "truncate",
28408 : "l", (long) new_size);
28409 0 : if (retval == NULL)
28410 : {
28411 0 : Py_XDECREF(resultobj);
28412 : resultobj = NULL;
28413 : }
28414 : else
28415 : {
28416 0 : Py_DECREF(retval);
28417 :
28418 0 : retval = PyObject_CallMethod(bytesio2,
28419 : "getbuffer", NULL);
28420 0 : if (retval == NULL
28421 0 : || PyObject_GetBuffer(retval, &view2,
28422 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28423 : {
28424 0 : Py_XDECREF(resultobj);
28425 : resultobj = NULL;
28426 : }
28427 :
28428 0 : Py_XDECREF(retval);
28429 :
28430 0 : if (resultobj && view2.len
28431 : != new_size)
28432 : {
28433 0 : Py_XDECREF(resultobj);
28434 0 : resultobj = NULL;
28435 0 : PyErr_Format(PyExc_ValueError,
28436 : "Expected buffer of length %zu, got %zi",
28437 : new_size,
28438 : view2.len);
28439 : }
28440 : }
28441 : }
28442 : }
28443 0 : if (resultobj)
28444 0 : memcpy(view2.buf, new_data, new_size);
28445 : }
28446 :
28447 :
28448 :
28449 : }
28450 :
28451 : /* Free the temporary wrapper, if any. */
28452 0 : if (wrapper2)
28453 0 : gpgme_data_release(wrapper2);
28454 0 : Py_XDECREF (bytesio2);
28455 0 : if (have_view2 && view2.buf)
28456 0 : PyBuffer_Release(&view2);
28457 : }
28458 : return resultobj;
28459 : fail:
28460 : {
28461 : /* See whether we need to update the Python buffer. */
28462 : if (resultobj && wrapper2 && view2.buf)
28463 : {
28464 : int dirty;
28465 : char *new_data = NULL;
28466 : size_t new_size;
28467 :
28468 :
28469 : new_data = wrapper2->data.mem.buffer;
28470 : new_size = wrapper2->data.mem.length;
28471 : dirty = new_data != NULL;
28472 :
28473 :
28474 :
28475 :
28476 :
28477 :
28478 :
28479 : if (dirty)
28480 : {
28481 : /* The buffer is dirty. */
28482 : if (view2.readonly)
28483 : {
28484 : Py_XDECREF(resultobj);
28485 : resultobj = NULL;
28486 : PyErr_SetString(PyExc_ValueError,
28487 : "cannot update read-only buffer");
28488 : }
28489 :
28490 : /* See if we need to truncate the buffer. */
28491 : if (resultobj && view2.len != new_size)
28492 : {
28493 : if (bytesio2 == NULL)
28494 : {
28495 : Py_XDECREF(resultobj);
28496 : resultobj = NULL;
28497 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28498 : }
28499 : else
28500 : {
28501 : PyObject *retval;
28502 : PyBuffer_Release(&view2);
28503 : assert(view2.obj == NULL);
28504 : retval = PyObject_CallMethod(bytesio2, "truncate",
28505 : "l", (long) new_size);
28506 : if (retval == NULL)
28507 : {
28508 : Py_XDECREF(resultobj);
28509 : resultobj = NULL;
28510 : }
28511 : else
28512 : {
28513 : Py_DECREF(retval);
28514 :
28515 : retval = PyObject_CallMethod(bytesio2,
28516 : "getbuffer", NULL);
28517 : if (retval == NULL
28518 : || PyObject_GetBuffer(retval, &view2,
28519 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28520 : {
28521 : Py_XDECREF(resultobj);
28522 : resultobj = NULL;
28523 : }
28524 :
28525 : Py_XDECREF(retval);
28526 :
28527 : if (resultobj && view2.len
28528 : != new_size)
28529 : {
28530 : Py_XDECREF(resultobj);
28531 : resultobj = NULL;
28532 : PyErr_Format(PyExc_ValueError,
28533 : "Expected buffer of length %zu, got %zi",
28534 : new_size,
28535 : view2.len);
28536 : }
28537 : }
28538 : }
28539 : }
28540 : if (resultobj)
28541 : memcpy(view2.buf, new_data, new_size);
28542 : }
28543 :
28544 :
28545 :
28546 : }
28547 :
28548 : /* Free the temporary wrapper, if any. */
28549 0 : if (wrapper2)
28550 0 : gpgme_data_release(wrapper2);
28551 0 : Py_XDECREF (bytesio2);
28552 : if (have_view2 && view2.buf)
28553 : PyBuffer_Release(&view2);
28554 : }
28555 : return NULL;
28556 : }
28557 :
28558 :
28559 36 : SWIGINTERN PyObject *_wrap__gpgme_op_genkey_result_seckey_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28560 36 : PyObject *resultobj = 0;
28561 36 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28562 36 : void *argp1 = 0 ;
28563 36 : int res1 = 0 ;
28564 36 : PyObject * obj0 = 0 ;
28565 : gpgme_data_t result;
28566 :
28567 36 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_genkey_result_seckey_get",&obj0)) SWIG_fail;
28568 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, 0 | 0 );
28569 36 : if (!SWIG_IsOK(res1)) {
28570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_genkey_result_seckey_get" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28571 : }
28572 36 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28573 : {
28574 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28575 36 : result = (gpgme_data_t) ((arg1)->seckey);
28576 36 : SWIG_PYTHON_THREAD_END_ALLOW;
28577 : }
28578 36 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
28579 36 : return resultobj;
28580 : fail:
28581 : return NULL;
28582 : }
28583 :
28584 :
28585 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 0 : PyObject *resultobj = 0;
28587 0 : struct _gpgme_op_genkey_result *result = 0 ;
28588 :
28589 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_genkey_result")) SWIG_fail;
28590 : {
28591 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28592 0 : result = (struct _gpgme_op_genkey_result *)calloc(1, sizeof(struct _gpgme_op_genkey_result));
28593 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28594 : }
28595 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result, SWIG_POINTER_NEW | 0 );
28596 0 : return resultobj;
28597 : fail:
28598 : return NULL;
28599 : }
28600 :
28601 :
28602 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28603 0 : PyObject *resultobj = 0;
28604 0 : struct _gpgme_op_genkey_result *arg1 = (struct _gpgme_op_genkey_result *) 0 ;
28605 0 : void *argp1 = 0 ;
28606 0 : int res1 = 0 ;
28607 0 : PyObject * obj0 = 0 ;
28608 :
28609 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_genkey_result",&obj0)) SWIG_fail;
28610 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_genkey_result, SWIG_POINTER_DISOWN | 0 );
28611 0 : if (!SWIG_IsOK(res1)) {
28612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_genkey_result" "', argument " "1"" of type '" "struct _gpgme_op_genkey_result *""'");
28613 : }
28614 0 : arg1 = (struct _gpgme_op_genkey_result *)(argp1);
28615 : {
28616 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28617 0 : free((char *) arg1);
28618 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28619 : }
28620 0 : resultobj = SWIG_Py_Void();
28621 0 : return resultobj;
28622 : fail:
28623 : return NULL;
28624 : }
28625 :
28626 :
28627 27 : SWIGINTERN PyObject *_gpgme_op_genkey_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28628 : PyObject *obj;
28629 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
28630 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_genkey_result, SWIG_NewClientData(obj));
28631 27 : return SWIG_Py_Void();
28632 : }
28633 :
28634 0 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28635 0 : PyObject *resultobj = 0;
28636 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
28637 0 : char *arg2 = (char *) 0 ;
28638 0 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
28639 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
28640 0 : void *argp1 = 0 ;
28641 0 : int res1 = 0 ;
28642 0 : PyObject *encodedInput2 = NULL ;
28643 0 : gpgme_data_t wrapper3 = NULL ;
28644 0 : PyObject *bytesio3 = NULL ;
28645 : Py_buffer view3 ;
28646 0 : int have_view3 = 0 ;
28647 0 : gpgme_data_t wrapper4 = NULL ;
28648 0 : PyObject *bytesio4 = NULL ;
28649 : Py_buffer view4 ;
28650 0 : int have_view4 = 0 ;
28651 0 : PyObject * obj0 = 0 ;
28652 0 : PyObject * obj1 = 0 ;
28653 0 : PyObject * obj2 = 0 ;
28654 0 : PyObject * obj3 = 0 ;
28655 : gpgme_error_t result;
28656 :
28657 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28658 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
28659 0 : if (!SWIG_IsOK(res1)) {
28660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
28661 : }
28662 0 : arg1 = (gpgme_ctx_t)(argp1);
28663 : {
28664 0 : if (obj1 == Py_None)
28665 : arg2 = NULL;
28666 0 : else if (PyUnicode_Check(obj1))
28667 : {
28668 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
28669 0 : if (encodedInput2 == NULL)
28670 : return NULL;
28671 0 : arg2 = PyBytes_AsString(encodedInput2);
28672 : }
28673 0 : else if (PyBytes_Check(obj1))
28674 0 : arg2 = PyBytes_AsString(obj1);
28675 : else {
28676 0 : PyErr_Format(PyExc_TypeError,
28677 : "arg %d: expected str, bytes, or None, got %s",
28678 : 2, obj1->ob_type->tp_name);
28679 0 : return NULL;
28680 : }
28681 : }
28682 : {
28683 : /* If we create a temporary wrapper3 object, we will store it in
28684 : wrapperN, where N is 3. Here in this fragment, SWIG will
28685 : automatically append 3. */
28686 0 : memset(&view3, 0, sizeof view3);
28687 0 : if (obj2 == Py_None)
28688 0 : arg3 = NULL;
28689 : else {
28690 : PyObject *pypointer;
28691 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
28692 : &bytesio3, &view3);
28693 0 : if (pypointer == NULL)
28694 : return NULL;
28695 0 : have_view3 = !! view3.obj;
28696 :
28697 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
28698 :
28699 : /* Following code is from swig's python.swg. */
28700 :
28701 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
28702 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
28703 0 : Py_DECREF(pypointer);
28704 : return NULL;
28705 : }
28706 0 : Py_DECREF(pypointer);
28707 : }
28708 : }
28709 : {
28710 : /* If we create a temporary wrapper4 object, we will store it in
28711 : wrapperN, where N is 4. Here in this fragment, SWIG will
28712 : automatically append 4. */
28713 0 : memset(&view4, 0, sizeof view4);
28714 0 : if (obj3 == Py_None)
28715 0 : arg4 = NULL;
28716 : else {
28717 : PyObject *pypointer;
28718 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
28719 : &bytesio4, &view4);
28720 0 : if (pypointer == NULL)
28721 : return NULL;
28722 0 : have_view4 = !! view4.obj;
28723 :
28724 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
28725 :
28726 : /* Following code is from swig's python.swg. */
28727 :
28728 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
28729 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
28730 0 : Py_DECREF(pypointer);
28731 : return NULL;
28732 : }
28733 0 : Py_DECREF(pypointer);
28734 : }
28735 : }
28736 : {
28737 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
28738 0 : result = gpgme_op_genkey_start(arg1,(char const *)arg2,arg3,arg4);
28739 0 : SWIG_PYTHON_THREAD_END_ALLOW;
28740 : }
28741 : {
28742 0 : resultobj = PyLong_FromLong(result);
28743 : }
28744 : {
28745 0 : Py_XDECREF(encodedInput2);
28746 : }
28747 : {
28748 : /* See whether we need to update the Python buffer. */
28749 0 : if (resultobj && wrapper3 && view3.buf)
28750 : {
28751 : int dirty;
28752 0 : char *new_data = NULL;
28753 : size_t new_size;
28754 :
28755 :
28756 0 : new_data = wrapper3->data.mem.buffer;
28757 0 : new_size = wrapper3->data.mem.length;
28758 0 : dirty = new_data != NULL;
28759 :
28760 :
28761 :
28762 :
28763 :
28764 :
28765 :
28766 0 : if (dirty)
28767 : {
28768 : /* The buffer is dirty. */
28769 0 : if (view3.readonly)
28770 : {
28771 0 : Py_XDECREF(resultobj);
28772 0 : resultobj = NULL;
28773 0 : PyErr_SetString(PyExc_ValueError,
28774 : "cannot update read-only buffer");
28775 : }
28776 :
28777 : /* See if we need to truncate the buffer. */
28778 0 : if (resultobj && view3.len != new_size)
28779 : {
28780 0 : if (bytesio3 == NULL)
28781 : {
28782 0 : Py_XDECREF(resultobj);
28783 0 : resultobj = NULL;
28784 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28785 : }
28786 : else
28787 : {
28788 : PyObject *retval;
28789 0 : PyBuffer_Release(&view3);
28790 : assert(view3.obj == NULL);
28791 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
28792 : "l", (long) new_size);
28793 0 : if (retval == NULL)
28794 : {
28795 0 : Py_XDECREF(resultobj);
28796 : resultobj = NULL;
28797 : }
28798 : else
28799 : {
28800 0 : Py_DECREF(retval);
28801 :
28802 0 : retval = PyObject_CallMethod(bytesio3,
28803 : "getbuffer", NULL);
28804 0 : if (retval == NULL
28805 0 : || PyObject_GetBuffer(retval, &view3,
28806 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28807 : {
28808 0 : Py_XDECREF(resultobj);
28809 : resultobj = NULL;
28810 : }
28811 :
28812 0 : Py_XDECREF(retval);
28813 :
28814 0 : if (resultobj && view3.len
28815 : != new_size)
28816 : {
28817 0 : Py_XDECREF(resultobj);
28818 0 : resultobj = NULL;
28819 0 : PyErr_Format(PyExc_ValueError,
28820 : "Expected buffer of length %zu, got %zi",
28821 : new_size,
28822 : view3.len);
28823 : }
28824 : }
28825 : }
28826 : }
28827 0 : if (resultobj)
28828 0 : memcpy(view3.buf, new_data, new_size);
28829 : }
28830 :
28831 :
28832 :
28833 : }
28834 :
28835 : /* Free the temporary wrapper, if any. */
28836 0 : if (wrapper3)
28837 0 : gpgme_data_release(wrapper3);
28838 0 : Py_XDECREF (bytesio3);
28839 0 : if (have_view3 && view3.buf)
28840 0 : PyBuffer_Release(&view3);
28841 : }
28842 : {
28843 : /* See whether we need to update the Python buffer. */
28844 0 : if (resultobj && wrapper4 && view4.buf)
28845 : {
28846 : int dirty;
28847 0 : char *new_data = NULL;
28848 : size_t new_size;
28849 :
28850 :
28851 0 : new_data = wrapper4->data.mem.buffer;
28852 0 : new_size = wrapper4->data.mem.length;
28853 0 : dirty = new_data != NULL;
28854 :
28855 :
28856 :
28857 :
28858 :
28859 :
28860 :
28861 0 : if (dirty)
28862 : {
28863 : /* The buffer is dirty. */
28864 0 : if (view4.readonly)
28865 : {
28866 0 : Py_XDECREF(resultobj);
28867 0 : resultobj = NULL;
28868 0 : PyErr_SetString(PyExc_ValueError,
28869 : "cannot update read-only buffer");
28870 : }
28871 :
28872 : /* See if we need to truncate the buffer. */
28873 0 : if (resultobj && view4.len != new_size)
28874 : {
28875 0 : if (bytesio4 == NULL)
28876 : {
28877 0 : Py_XDECREF(resultobj);
28878 0 : resultobj = NULL;
28879 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28880 : }
28881 : else
28882 : {
28883 : PyObject *retval;
28884 0 : PyBuffer_Release(&view4);
28885 : assert(view4.obj == NULL);
28886 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
28887 : "l", (long) new_size);
28888 0 : if (retval == NULL)
28889 : {
28890 0 : Py_XDECREF(resultobj);
28891 : resultobj = NULL;
28892 : }
28893 : else
28894 : {
28895 0 : Py_DECREF(retval);
28896 :
28897 0 : retval = PyObject_CallMethod(bytesio4,
28898 : "getbuffer", NULL);
28899 0 : if (retval == NULL
28900 0 : || PyObject_GetBuffer(retval, &view4,
28901 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
28902 : {
28903 0 : Py_XDECREF(resultobj);
28904 : resultobj = NULL;
28905 : }
28906 :
28907 0 : Py_XDECREF(retval);
28908 :
28909 0 : if (resultobj && view4.len
28910 : != new_size)
28911 : {
28912 0 : Py_XDECREF(resultobj);
28913 0 : resultobj = NULL;
28914 0 : PyErr_Format(PyExc_ValueError,
28915 : "Expected buffer of length %zu, got %zi",
28916 : new_size,
28917 : view4.len);
28918 : }
28919 : }
28920 : }
28921 : }
28922 0 : if (resultobj)
28923 0 : memcpy(view4.buf, new_data, new_size);
28924 : }
28925 :
28926 :
28927 :
28928 : }
28929 :
28930 : /* Free the temporary wrapper, if any. */
28931 0 : if (wrapper4)
28932 0 : gpgme_data_release(wrapper4);
28933 0 : Py_XDECREF (bytesio4);
28934 0 : if (have_view4 && view4.buf)
28935 0 : PyBuffer_Release(&view4);
28936 : }
28937 : return resultobj;
28938 : fail:
28939 : {
28940 : Py_XDECREF(encodedInput2);
28941 : }
28942 : {
28943 : /* See whether we need to update the Python buffer. */
28944 : if (resultobj && wrapper3 && view3.buf)
28945 : {
28946 : int dirty;
28947 : char *new_data = NULL;
28948 : size_t new_size;
28949 :
28950 :
28951 : new_data = wrapper3->data.mem.buffer;
28952 : new_size = wrapper3->data.mem.length;
28953 : dirty = new_data != NULL;
28954 :
28955 :
28956 :
28957 :
28958 :
28959 :
28960 :
28961 : if (dirty)
28962 : {
28963 : /* The buffer is dirty. */
28964 : if (view3.readonly)
28965 : {
28966 : Py_XDECREF(resultobj);
28967 : resultobj = NULL;
28968 : PyErr_SetString(PyExc_ValueError,
28969 : "cannot update read-only buffer");
28970 : }
28971 :
28972 : /* See if we need to truncate the buffer. */
28973 : if (resultobj && view3.len != new_size)
28974 : {
28975 : if (bytesio3 == NULL)
28976 : {
28977 : Py_XDECREF(resultobj);
28978 : resultobj = NULL;
28979 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
28980 : }
28981 : else
28982 : {
28983 : PyObject *retval;
28984 : PyBuffer_Release(&view3);
28985 : assert(view3.obj == NULL);
28986 : retval = PyObject_CallMethod(bytesio3, "truncate",
28987 : "l", (long) new_size);
28988 : if (retval == NULL)
28989 : {
28990 : Py_XDECREF(resultobj);
28991 : resultobj = NULL;
28992 : }
28993 : else
28994 : {
28995 : Py_DECREF(retval);
28996 :
28997 : retval = PyObject_CallMethod(bytesio3,
28998 : "getbuffer", NULL);
28999 : if (retval == NULL
29000 : || PyObject_GetBuffer(retval, &view3,
29001 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29002 : {
29003 : Py_XDECREF(resultobj);
29004 : resultobj = NULL;
29005 : }
29006 :
29007 : Py_XDECREF(retval);
29008 :
29009 : if (resultobj && view3.len
29010 : != new_size)
29011 : {
29012 : Py_XDECREF(resultobj);
29013 : resultobj = NULL;
29014 : PyErr_Format(PyExc_ValueError,
29015 : "Expected buffer of length %zu, got %zi",
29016 : new_size,
29017 : view3.len);
29018 : }
29019 : }
29020 : }
29021 : }
29022 : if (resultobj)
29023 : memcpy(view3.buf, new_data, new_size);
29024 : }
29025 :
29026 :
29027 :
29028 : }
29029 :
29030 : /* Free the temporary wrapper, if any. */
29031 0 : if (wrapper3)
29032 0 : gpgme_data_release(wrapper3);
29033 0 : Py_XDECREF (bytesio3);
29034 : if (have_view3 && view3.buf)
29035 : PyBuffer_Release(&view3);
29036 : }
29037 : {
29038 : /* See whether we need to update the Python buffer. */
29039 : if (resultobj && wrapper4 && view4.buf)
29040 : {
29041 : int dirty;
29042 : char *new_data = NULL;
29043 : size_t new_size;
29044 :
29045 :
29046 : new_data = wrapper4->data.mem.buffer;
29047 : new_size = wrapper4->data.mem.length;
29048 : dirty = new_data != NULL;
29049 :
29050 :
29051 :
29052 :
29053 :
29054 :
29055 :
29056 : if (dirty)
29057 : {
29058 : /* The buffer is dirty. */
29059 : if (view4.readonly)
29060 : {
29061 : Py_XDECREF(resultobj);
29062 : resultobj = NULL;
29063 : PyErr_SetString(PyExc_ValueError,
29064 : "cannot update read-only buffer");
29065 : }
29066 :
29067 : /* See if we need to truncate the buffer. */
29068 : if (resultobj && view4.len != new_size)
29069 : {
29070 : if (bytesio4 == NULL)
29071 : {
29072 : Py_XDECREF(resultobj);
29073 : resultobj = NULL;
29074 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29075 : }
29076 : else
29077 : {
29078 : PyObject *retval;
29079 : PyBuffer_Release(&view4);
29080 : assert(view4.obj == NULL);
29081 : retval = PyObject_CallMethod(bytesio4, "truncate",
29082 : "l", (long) new_size);
29083 : if (retval == NULL)
29084 : {
29085 : Py_XDECREF(resultobj);
29086 : resultobj = NULL;
29087 : }
29088 : else
29089 : {
29090 : Py_DECREF(retval);
29091 :
29092 : retval = PyObject_CallMethod(bytesio4,
29093 : "getbuffer", NULL);
29094 : if (retval == NULL
29095 : || PyObject_GetBuffer(retval, &view4,
29096 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29097 : {
29098 : Py_XDECREF(resultobj);
29099 : resultobj = NULL;
29100 : }
29101 :
29102 : Py_XDECREF(retval);
29103 :
29104 : if (resultobj && view4.len
29105 : != new_size)
29106 : {
29107 : Py_XDECREF(resultobj);
29108 : resultobj = NULL;
29109 : PyErr_Format(PyExc_ValueError,
29110 : "Expected buffer of length %zu, got %zi",
29111 : new_size,
29112 : view4.len);
29113 : }
29114 : }
29115 : }
29116 : }
29117 : if (resultobj)
29118 : memcpy(view4.buf, new_data, new_size);
29119 : }
29120 :
29121 :
29122 :
29123 : }
29124 :
29125 : /* Free the temporary wrapper, if any. */
29126 0 : if (wrapper4)
29127 0 : gpgme_data_release(wrapper4);
29128 0 : Py_XDECREF (bytesio4);
29129 : if (have_view4 && view4.buf)
29130 : PyBuffer_Release(&view4);
29131 : }
29132 : return NULL;
29133 : }
29134 :
29135 :
29136 2 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29137 2 : PyObject *resultobj = 0;
29138 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29139 2 : char *arg2 = (char *) 0 ;
29140 2 : gpgme_data_t arg3 = (gpgme_data_t) 0 ;
29141 2 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
29142 2 : void *argp1 = 0 ;
29143 2 : int res1 = 0 ;
29144 2 : PyObject *encodedInput2 = NULL ;
29145 2 : gpgme_data_t wrapper3 = NULL ;
29146 2 : PyObject *bytesio3 = NULL ;
29147 : Py_buffer view3 ;
29148 2 : int have_view3 = 0 ;
29149 2 : gpgme_data_t wrapper4 = NULL ;
29150 2 : PyObject *bytesio4 = NULL ;
29151 : Py_buffer view4 ;
29152 2 : int have_view4 = 0 ;
29153 2 : PyObject * obj0 = 0 ;
29154 2 : PyObject * obj1 = 0 ;
29155 2 : PyObject * obj2 = 0 ;
29156 2 : PyObject * obj3 = 0 ;
29157 : gpgme_error_t result;
29158 :
29159 2 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_genkey",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29160 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29161 2 : if (!SWIG_IsOK(res1)) {
29162 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29163 : }
29164 2 : arg1 = (gpgme_ctx_t)(argp1);
29165 : {
29166 2 : if (obj1 == Py_None)
29167 : arg2 = NULL;
29168 2 : else if (PyUnicode_Check(obj1))
29169 : {
29170 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
29171 2 : if (encodedInput2 == NULL)
29172 : return NULL;
29173 2 : arg2 = PyBytes_AsString(encodedInput2);
29174 : }
29175 0 : else if (PyBytes_Check(obj1))
29176 0 : arg2 = PyBytes_AsString(obj1);
29177 : else {
29178 0 : PyErr_Format(PyExc_TypeError,
29179 : "arg %d: expected str, bytes, or None, got %s",
29180 : 2, obj1->ob_type->tp_name);
29181 0 : return NULL;
29182 : }
29183 : }
29184 : {
29185 : /* If we create a temporary wrapper3 object, we will store it in
29186 : wrapperN, where N is 3. Here in this fragment, SWIG will
29187 : automatically append 3. */
29188 2 : memset(&view3, 0, sizeof view3);
29189 2 : if (obj2 == Py_None)
29190 2 : arg3 = NULL;
29191 : else {
29192 : PyObject *pypointer;
29193 0 : pypointer = _gpg_obj2gpgme_data_t(obj2, 3, &wrapper3,
29194 : &bytesio3, &view3);
29195 0 : if (pypointer == NULL)
29196 : return NULL;
29197 0 : have_view3 = !! view3.obj;
29198 :
29199 : /* input = obj2, 1 = arg3, 1_descriptor = SWIGTYPE_p_gpgme_data */
29200 :
29201 : /* Following code is from swig's python.swg. */
29202 :
29203 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg3, SWIGTYPE_p_gpgme_data,
29204 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29205 0 : Py_DECREF(pypointer);
29206 : return NULL;
29207 : }
29208 0 : Py_DECREF(pypointer);
29209 : }
29210 : }
29211 : {
29212 : /* If we create a temporary wrapper4 object, we will store it in
29213 : wrapperN, where N is 4. Here in this fragment, SWIG will
29214 : automatically append 4. */
29215 2 : memset(&view4, 0, sizeof view4);
29216 2 : if (obj3 == Py_None)
29217 2 : arg4 = NULL;
29218 : else {
29219 : PyObject *pypointer;
29220 0 : pypointer = _gpg_obj2gpgme_data_t(obj3, 4, &wrapper4,
29221 : &bytesio4, &view4);
29222 0 : if (pypointer == NULL)
29223 : return NULL;
29224 0 : have_view4 = !! view4.obj;
29225 :
29226 : /* input = obj3, 1 = arg4, 1_descriptor = SWIGTYPE_p_gpgme_data */
29227 :
29228 : /* Following code is from swig's python.swg. */
29229 :
29230 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg4, SWIGTYPE_p_gpgme_data,
29231 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
29232 0 : Py_DECREF(pypointer);
29233 : return NULL;
29234 : }
29235 0 : Py_DECREF(pypointer);
29236 : }
29237 : }
29238 : {
29239 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29240 2 : result = gpgme_op_genkey(arg1,(char const *)arg2,arg3,arg4);
29241 2 : SWIG_PYTHON_THREAD_END_ALLOW;
29242 : }
29243 : {
29244 2 : resultobj = PyLong_FromLong(result);
29245 : }
29246 : {
29247 2 : Py_XDECREF(encodedInput2);
29248 : }
29249 : {
29250 : /* See whether we need to update the Python buffer. */
29251 2 : if (resultobj && wrapper3 && view3.buf)
29252 : {
29253 : int dirty;
29254 0 : char *new_data = NULL;
29255 : size_t new_size;
29256 :
29257 :
29258 0 : new_data = wrapper3->data.mem.buffer;
29259 0 : new_size = wrapper3->data.mem.length;
29260 0 : dirty = new_data != NULL;
29261 :
29262 :
29263 :
29264 :
29265 :
29266 :
29267 :
29268 0 : if (dirty)
29269 : {
29270 : /* The buffer is dirty. */
29271 0 : if (view3.readonly)
29272 : {
29273 0 : Py_XDECREF(resultobj);
29274 0 : resultobj = NULL;
29275 0 : PyErr_SetString(PyExc_ValueError,
29276 : "cannot update read-only buffer");
29277 : }
29278 :
29279 : /* See if we need to truncate the buffer. */
29280 0 : if (resultobj && view3.len != new_size)
29281 : {
29282 0 : if (bytesio3 == NULL)
29283 : {
29284 0 : Py_XDECREF(resultobj);
29285 0 : resultobj = NULL;
29286 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29287 : }
29288 : else
29289 : {
29290 : PyObject *retval;
29291 0 : PyBuffer_Release(&view3);
29292 : assert(view3.obj == NULL);
29293 0 : retval = PyObject_CallMethod(bytesio3, "truncate",
29294 : "l", (long) new_size);
29295 0 : if (retval == NULL)
29296 : {
29297 0 : Py_XDECREF(resultobj);
29298 : resultobj = NULL;
29299 : }
29300 : else
29301 : {
29302 0 : Py_DECREF(retval);
29303 :
29304 0 : retval = PyObject_CallMethod(bytesio3,
29305 : "getbuffer", NULL);
29306 0 : if (retval == NULL
29307 0 : || PyObject_GetBuffer(retval, &view3,
29308 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29309 : {
29310 0 : Py_XDECREF(resultobj);
29311 : resultobj = NULL;
29312 : }
29313 :
29314 0 : Py_XDECREF(retval);
29315 :
29316 0 : if (resultobj && view3.len
29317 : != new_size)
29318 : {
29319 0 : Py_XDECREF(resultobj);
29320 0 : resultobj = NULL;
29321 0 : PyErr_Format(PyExc_ValueError,
29322 : "Expected buffer of length %zu, got %zi",
29323 : new_size,
29324 : view3.len);
29325 : }
29326 : }
29327 : }
29328 : }
29329 0 : if (resultobj)
29330 0 : memcpy(view3.buf, new_data, new_size);
29331 : }
29332 :
29333 :
29334 :
29335 : }
29336 :
29337 : /* Free the temporary wrapper, if any. */
29338 2 : if (wrapper3)
29339 0 : gpgme_data_release(wrapper3);
29340 2 : Py_XDECREF (bytesio3);
29341 2 : if (have_view3 && view3.buf)
29342 0 : PyBuffer_Release(&view3);
29343 : }
29344 : {
29345 : /* See whether we need to update the Python buffer. */
29346 2 : if (resultobj && wrapper4 && view4.buf)
29347 : {
29348 : int dirty;
29349 0 : char *new_data = NULL;
29350 : size_t new_size;
29351 :
29352 :
29353 0 : new_data = wrapper4->data.mem.buffer;
29354 0 : new_size = wrapper4->data.mem.length;
29355 0 : dirty = new_data != NULL;
29356 :
29357 :
29358 :
29359 :
29360 :
29361 :
29362 :
29363 0 : if (dirty)
29364 : {
29365 : /* The buffer is dirty. */
29366 0 : if (view4.readonly)
29367 : {
29368 0 : Py_XDECREF(resultobj);
29369 0 : resultobj = NULL;
29370 0 : PyErr_SetString(PyExc_ValueError,
29371 : "cannot update read-only buffer");
29372 : }
29373 :
29374 : /* See if we need to truncate the buffer. */
29375 0 : if (resultobj && view4.len != new_size)
29376 : {
29377 0 : if (bytesio4 == NULL)
29378 : {
29379 0 : Py_XDECREF(resultobj);
29380 0 : resultobj = NULL;
29381 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29382 : }
29383 : else
29384 : {
29385 : PyObject *retval;
29386 0 : PyBuffer_Release(&view4);
29387 : assert(view4.obj == NULL);
29388 0 : retval = PyObject_CallMethod(bytesio4, "truncate",
29389 : "l", (long) new_size);
29390 0 : if (retval == NULL)
29391 : {
29392 0 : Py_XDECREF(resultobj);
29393 : resultobj = NULL;
29394 : }
29395 : else
29396 : {
29397 0 : Py_DECREF(retval);
29398 :
29399 0 : retval = PyObject_CallMethod(bytesio4,
29400 : "getbuffer", NULL);
29401 0 : if (retval == NULL
29402 0 : || PyObject_GetBuffer(retval, &view4,
29403 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29404 : {
29405 0 : Py_XDECREF(resultobj);
29406 : resultobj = NULL;
29407 : }
29408 :
29409 0 : Py_XDECREF(retval);
29410 :
29411 0 : if (resultobj && view4.len
29412 : != new_size)
29413 : {
29414 0 : Py_XDECREF(resultobj);
29415 0 : resultobj = NULL;
29416 0 : PyErr_Format(PyExc_ValueError,
29417 : "Expected buffer of length %zu, got %zi",
29418 : new_size,
29419 : view4.len);
29420 : }
29421 : }
29422 : }
29423 : }
29424 0 : if (resultobj)
29425 0 : memcpy(view4.buf, new_data, new_size);
29426 : }
29427 :
29428 :
29429 :
29430 : }
29431 :
29432 : /* Free the temporary wrapper, if any. */
29433 2 : if (wrapper4)
29434 0 : gpgme_data_release(wrapper4);
29435 2 : Py_XDECREF (bytesio4);
29436 2 : if (have_view4 && view4.buf)
29437 0 : PyBuffer_Release(&view4);
29438 : }
29439 : return resultobj;
29440 : fail:
29441 : {
29442 : Py_XDECREF(encodedInput2);
29443 : }
29444 : {
29445 : /* See whether we need to update the Python buffer. */
29446 : if (resultobj && wrapper3 && view3.buf)
29447 : {
29448 : int dirty;
29449 : char *new_data = NULL;
29450 : size_t new_size;
29451 :
29452 :
29453 : new_data = wrapper3->data.mem.buffer;
29454 : new_size = wrapper3->data.mem.length;
29455 : dirty = new_data != NULL;
29456 :
29457 :
29458 :
29459 :
29460 :
29461 :
29462 :
29463 : if (dirty)
29464 : {
29465 : /* The buffer is dirty. */
29466 : if (view3.readonly)
29467 : {
29468 : Py_XDECREF(resultobj);
29469 : resultobj = NULL;
29470 : PyErr_SetString(PyExc_ValueError,
29471 : "cannot update read-only buffer");
29472 : }
29473 :
29474 : /* See if we need to truncate the buffer. */
29475 : if (resultobj && view3.len != new_size)
29476 : {
29477 : if (bytesio3 == NULL)
29478 : {
29479 : Py_XDECREF(resultobj);
29480 : resultobj = NULL;
29481 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29482 : }
29483 : else
29484 : {
29485 : PyObject *retval;
29486 : PyBuffer_Release(&view3);
29487 : assert(view3.obj == NULL);
29488 : retval = PyObject_CallMethod(bytesio3, "truncate",
29489 : "l", (long) new_size);
29490 : if (retval == NULL)
29491 : {
29492 : Py_XDECREF(resultobj);
29493 : resultobj = NULL;
29494 : }
29495 : else
29496 : {
29497 : Py_DECREF(retval);
29498 :
29499 : retval = PyObject_CallMethod(bytesio3,
29500 : "getbuffer", NULL);
29501 : if (retval == NULL
29502 : || PyObject_GetBuffer(retval, &view3,
29503 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29504 : {
29505 : Py_XDECREF(resultobj);
29506 : resultobj = NULL;
29507 : }
29508 :
29509 : Py_XDECREF(retval);
29510 :
29511 : if (resultobj && view3.len
29512 : != new_size)
29513 : {
29514 : Py_XDECREF(resultobj);
29515 : resultobj = NULL;
29516 : PyErr_Format(PyExc_ValueError,
29517 : "Expected buffer of length %zu, got %zi",
29518 : new_size,
29519 : view3.len);
29520 : }
29521 : }
29522 : }
29523 : }
29524 : if (resultobj)
29525 : memcpy(view3.buf, new_data, new_size);
29526 : }
29527 :
29528 :
29529 :
29530 : }
29531 :
29532 : /* Free the temporary wrapper, if any. */
29533 0 : if (wrapper3)
29534 0 : gpgme_data_release(wrapper3);
29535 0 : Py_XDECREF (bytesio3);
29536 : if (have_view3 && view3.buf)
29537 : PyBuffer_Release(&view3);
29538 : }
29539 : {
29540 : /* See whether we need to update the Python buffer. */
29541 : if (resultobj && wrapper4 && view4.buf)
29542 : {
29543 : int dirty;
29544 : char *new_data = NULL;
29545 : size_t new_size;
29546 :
29547 :
29548 : new_data = wrapper4->data.mem.buffer;
29549 : new_size = wrapper4->data.mem.length;
29550 : dirty = new_data != NULL;
29551 :
29552 :
29553 :
29554 :
29555 :
29556 :
29557 :
29558 : if (dirty)
29559 : {
29560 : /* The buffer is dirty. */
29561 : if (view4.readonly)
29562 : {
29563 : Py_XDECREF(resultobj);
29564 : resultobj = NULL;
29565 : PyErr_SetString(PyExc_ValueError,
29566 : "cannot update read-only buffer");
29567 : }
29568 :
29569 : /* See if we need to truncate the buffer. */
29570 : if (resultobj && view4.len != new_size)
29571 : {
29572 : if (bytesio4 == NULL)
29573 : {
29574 : Py_XDECREF(resultobj);
29575 : resultobj = NULL;
29576 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
29577 : }
29578 : else
29579 : {
29580 : PyObject *retval;
29581 : PyBuffer_Release(&view4);
29582 : assert(view4.obj == NULL);
29583 : retval = PyObject_CallMethod(bytesio4, "truncate",
29584 : "l", (long) new_size);
29585 : if (retval == NULL)
29586 : {
29587 : Py_XDECREF(resultobj);
29588 : resultobj = NULL;
29589 : }
29590 : else
29591 : {
29592 : Py_DECREF(retval);
29593 :
29594 : retval = PyObject_CallMethod(bytesio4,
29595 : "getbuffer", NULL);
29596 : if (retval == NULL
29597 : || PyObject_GetBuffer(retval, &view4,
29598 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
29599 : {
29600 : Py_XDECREF(resultobj);
29601 : resultobj = NULL;
29602 : }
29603 :
29604 : Py_XDECREF(retval);
29605 :
29606 : if (resultobj && view4.len
29607 : != new_size)
29608 : {
29609 : Py_XDECREF(resultobj);
29610 : resultobj = NULL;
29611 : PyErr_Format(PyExc_ValueError,
29612 : "Expected buffer of length %zu, got %zi",
29613 : new_size,
29614 : view4.len);
29615 : }
29616 : }
29617 : }
29618 : }
29619 : if (resultobj)
29620 : memcpy(view4.buf, new_data, new_size);
29621 : }
29622 :
29623 :
29624 :
29625 : }
29626 :
29627 : /* Free the temporary wrapper, if any. */
29628 0 : if (wrapper4)
29629 0 : gpgme_data_release(wrapper4);
29630 0 : Py_XDECREF (bytesio4);
29631 : if (have_view4 && view4.buf)
29632 : PyBuffer_Release(&view4);
29633 : }
29634 : return NULL;
29635 : }
29636 :
29637 :
29638 0 : SWIGINTERN PyObject *_wrap_gpgme_op_createkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29639 0 : PyObject *resultobj = 0;
29640 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29641 0 : char *arg2 = (char *) 0 ;
29642 0 : char *arg3 = (char *) 0 ;
29643 : unsigned long arg4 ;
29644 : unsigned long arg5 ;
29645 0 : gpgme_key_t arg6 = (gpgme_key_t) 0 ;
29646 : unsigned int arg7 ;
29647 0 : void *argp1 = 0 ;
29648 0 : int res1 = 0 ;
29649 0 : PyObject *encodedInput2 = NULL ;
29650 0 : PyObject *encodedInput3 = NULL ;
29651 : unsigned long val4 ;
29652 0 : int ecode4 = 0 ;
29653 : unsigned long val5 ;
29654 0 : int ecode5 = 0 ;
29655 0 : void *argp6 = 0 ;
29656 0 : int res6 = 0 ;
29657 : unsigned int val7 ;
29658 0 : int ecode7 = 0 ;
29659 0 : PyObject * obj0 = 0 ;
29660 0 : PyObject * obj1 = 0 ;
29661 0 : PyObject * obj2 = 0 ;
29662 0 : PyObject * obj3 = 0 ;
29663 0 : PyObject * obj4 = 0 ;
29664 0 : PyObject * obj5 = 0 ;
29665 0 : PyObject * obj6 = 0 ;
29666 : gpgme_error_t result;
29667 :
29668 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_createkey_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29669 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29670 0 : if (!SWIG_IsOK(res1)) {
29671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29672 : }
29673 0 : arg1 = (gpgme_ctx_t)(argp1);
29674 : {
29675 0 : if (obj1 == Py_None)
29676 : arg2 = NULL;
29677 0 : else if (PyUnicode_Check(obj1))
29678 : {
29679 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
29680 0 : if (encodedInput2 == NULL)
29681 : return NULL;
29682 0 : arg2 = PyBytes_AsString(encodedInput2);
29683 : }
29684 0 : else if (PyBytes_Check(obj1))
29685 0 : arg2 = PyBytes_AsString(obj1);
29686 : else {
29687 0 : PyErr_Format(PyExc_TypeError,
29688 : "arg %d: expected str, bytes, or None, got %s",
29689 : 2, obj1->ob_type->tp_name);
29690 0 : return NULL;
29691 : }
29692 : }
29693 : {
29694 0 : if (obj2 == Py_None)
29695 : arg3 = NULL;
29696 0 : else if (PyUnicode_Check(obj2))
29697 : {
29698 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
29699 0 : if (encodedInput3 == NULL)
29700 : return NULL;
29701 0 : arg3 = PyBytes_AsString(encodedInput3);
29702 : }
29703 0 : else if (PyBytes_Check(obj2))
29704 0 : arg3 = PyBytes_AsString(obj2);
29705 : else {
29706 0 : PyErr_Format(PyExc_TypeError,
29707 : "arg %d: expected str, bytes, or None, got %s",
29708 : 3, obj2->ob_type->tp_name);
29709 0 : return NULL;
29710 : }
29711 : }
29712 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
29713 0 : if (!SWIG_IsOK(ecode4)) {
29714 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createkey_start" "', argument " "4"" of type '" "unsigned long""'");
29715 : }
29716 0 : arg4 = (unsigned long)(val4);
29717 0 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
29718 0 : if (!SWIG_IsOK(ecode5)) {
29719 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createkey_start" "', argument " "5"" of type '" "unsigned long""'");
29720 : }
29721 0 : arg5 = (unsigned long)(val5);
29722 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__gpgme_key, 0 | 0 );
29723 0 : if (!SWIG_IsOK(res6)) {
29724 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_createkey_start" "', argument " "6"" of type '" "gpgme_key_t""'");
29725 : }
29726 0 : arg6 = (gpgme_key_t)(argp6);
29727 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
29728 0 : if (!SWIG_IsOK(ecode7)) {
29729 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_createkey_start" "', argument " "7"" of type '" "unsigned int""'");
29730 : }
29731 0 : arg7 = (unsigned int)(val7);
29732 : {
29733 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29734 0 : result = gpgme_op_createkey_start(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
29735 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29736 : }
29737 : {
29738 0 : resultobj = PyLong_FromLong(result);
29739 : }
29740 : {
29741 0 : Py_XDECREF(encodedInput2);
29742 : }
29743 : {
29744 0 : Py_XDECREF(encodedInput3);
29745 : }
29746 : return resultobj;
29747 : fail:
29748 : {
29749 0 : Py_XDECREF(encodedInput2);
29750 : }
29751 : {
29752 0 : Py_XDECREF(encodedInput3);
29753 : }
29754 : return NULL;
29755 : }
29756 :
29757 :
29758 24 : SWIGINTERN PyObject *_wrap_gpgme_op_createkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29759 24 : PyObject *resultobj = 0;
29760 24 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29761 24 : char *arg2 = (char *) 0 ;
29762 24 : char *arg3 = (char *) 0 ;
29763 : unsigned long arg4 ;
29764 : unsigned long arg5 ;
29765 24 : gpgme_key_t arg6 = (gpgme_key_t) 0 ;
29766 : unsigned int arg7 ;
29767 24 : void *argp1 = 0 ;
29768 24 : int res1 = 0 ;
29769 24 : PyObject *encodedInput2 = NULL ;
29770 24 : PyObject *encodedInput3 = NULL ;
29771 : unsigned long val4 ;
29772 24 : int ecode4 = 0 ;
29773 : unsigned long val5 ;
29774 24 : int ecode5 = 0 ;
29775 24 : void *argp6 = 0 ;
29776 24 : int res6 = 0 ;
29777 : unsigned int val7 ;
29778 24 : int ecode7 = 0 ;
29779 24 : PyObject * obj0 = 0 ;
29780 24 : PyObject * obj1 = 0 ;
29781 24 : PyObject * obj2 = 0 ;
29782 24 : PyObject * obj3 = 0 ;
29783 24 : PyObject * obj4 = 0 ;
29784 24 : PyObject * obj5 = 0 ;
29785 24 : PyObject * obj6 = 0 ;
29786 : gpgme_error_t result;
29787 :
29788 24 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_createkey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29789 24 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29790 24 : if (!SWIG_IsOK(res1)) {
29791 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29792 : }
29793 24 : arg1 = (gpgme_ctx_t)(argp1);
29794 : {
29795 24 : if (obj1 == Py_None)
29796 : arg2 = NULL;
29797 24 : else if (PyUnicode_Check(obj1))
29798 : {
29799 24 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
29800 24 : if (encodedInput2 == NULL)
29801 : return NULL;
29802 24 : arg2 = PyBytes_AsString(encodedInput2);
29803 : }
29804 0 : else if (PyBytes_Check(obj1))
29805 0 : arg2 = PyBytes_AsString(obj1);
29806 : else {
29807 0 : PyErr_Format(PyExc_TypeError,
29808 : "arg %d: expected str, bytes, or None, got %s",
29809 : 2, obj1->ob_type->tp_name);
29810 0 : return NULL;
29811 : }
29812 : }
29813 : {
29814 24 : if (obj2 == Py_None)
29815 : arg3 = NULL;
29816 11 : else if (PyUnicode_Check(obj2))
29817 : {
29818 11 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
29819 11 : if (encodedInput3 == NULL)
29820 : return NULL;
29821 11 : arg3 = PyBytes_AsString(encodedInput3);
29822 : }
29823 0 : else if (PyBytes_Check(obj2))
29824 0 : arg3 = PyBytes_AsString(obj2);
29825 : else {
29826 0 : PyErr_Format(PyExc_TypeError,
29827 : "arg %d: expected str, bytes, or None, got %s",
29828 : 3, obj2->ob_type->tp_name);
29829 0 : return NULL;
29830 : }
29831 : }
29832 24 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
29833 24 : if (!SWIG_IsOK(ecode4)) {
29834 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createkey" "', argument " "4"" of type '" "unsigned long""'");
29835 : }
29836 24 : arg4 = (unsigned long)(val4);
29837 24 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
29838 24 : if (!SWIG_IsOK(ecode5)) {
29839 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createkey" "', argument " "5"" of type '" "unsigned long""'");
29840 : }
29841 24 : arg5 = (unsigned long)(val5);
29842 24 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p__gpgme_key, 0 | 0 );
29843 24 : if (!SWIG_IsOK(res6)) {
29844 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_createkey" "', argument " "6"" of type '" "gpgme_key_t""'");
29845 : }
29846 24 : arg6 = (gpgme_key_t)(argp6);
29847 48 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
29848 24 : if (!SWIG_IsOK(ecode7)) {
29849 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_createkey" "', argument " "7"" of type '" "unsigned int""'");
29850 : }
29851 24 : arg7 = (unsigned int)(val7);
29852 : {
29853 24 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29854 24 : result = gpgme_op_createkey(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
29855 24 : SWIG_PYTHON_THREAD_END_ALLOW;
29856 : }
29857 : {
29858 24 : resultobj = PyLong_FromLong(result);
29859 : }
29860 : {
29861 24 : Py_XDECREF(encodedInput2);
29862 : }
29863 : {
29864 24 : Py_XDECREF(encodedInput3);
29865 : }
29866 : return resultobj;
29867 : fail:
29868 : {
29869 0 : Py_XDECREF(encodedInput2);
29870 : }
29871 : {
29872 0 : Py_XDECREF(encodedInput3);
29873 : }
29874 : return NULL;
29875 : }
29876 :
29877 :
29878 0 : SWIGINTERN PyObject *_wrap_gpgme_op_createsubkey_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29879 0 : PyObject *resultobj = 0;
29880 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29881 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
29882 0 : char *arg3 = (char *) 0 ;
29883 : unsigned long arg4 ;
29884 : unsigned long arg5 ;
29885 : unsigned int arg6 ;
29886 0 : void *argp1 = 0 ;
29887 0 : int res1 = 0 ;
29888 0 : void *argp2 = 0 ;
29889 0 : int res2 = 0 ;
29890 0 : PyObject *encodedInput3 = NULL ;
29891 : unsigned long val4 ;
29892 0 : int ecode4 = 0 ;
29893 : unsigned long val5 ;
29894 0 : int ecode5 = 0 ;
29895 : unsigned int val6 ;
29896 0 : int ecode6 = 0 ;
29897 0 : PyObject * obj0 = 0 ;
29898 0 : PyObject * obj1 = 0 ;
29899 0 : PyObject * obj2 = 0 ;
29900 0 : PyObject * obj3 = 0 ;
29901 0 : PyObject * obj4 = 0 ;
29902 0 : PyObject * obj5 = 0 ;
29903 : gpgme_error_t result;
29904 :
29905 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_createsubkey_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29906 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29907 0 : if (!SWIG_IsOK(res1)) {
29908 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createsubkey_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
29909 : }
29910 0 : arg1 = (gpgme_ctx_t)(argp1);
29911 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
29912 0 : if (!SWIG_IsOK(res2)) {
29913 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_createsubkey_start" "', argument " "2"" of type '" "gpgme_key_t""'");
29914 : }
29915 0 : arg2 = (gpgme_key_t)(argp2);
29916 : {
29917 0 : if (obj2 == Py_None)
29918 : arg3 = NULL;
29919 0 : else if (PyUnicode_Check(obj2))
29920 : {
29921 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
29922 0 : if (encodedInput3 == NULL)
29923 : return NULL;
29924 0 : arg3 = PyBytes_AsString(encodedInput3);
29925 : }
29926 0 : else if (PyBytes_Check(obj2))
29927 0 : arg3 = PyBytes_AsString(obj2);
29928 : else {
29929 0 : PyErr_Format(PyExc_TypeError,
29930 : "arg %d: expected str, bytes, or None, got %s",
29931 : 3, obj2->ob_type->tp_name);
29932 0 : return NULL;
29933 : }
29934 : }
29935 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
29936 0 : if (!SWIG_IsOK(ecode4)) {
29937 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createsubkey_start" "', argument " "4"" of type '" "unsigned long""'");
29938 : }
29939 0 : arg4 = (unsigned long)(val4);
29940 0 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
29941 0 : if (!SWIG_IsOK(ecode5)) {
29942 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createsubkey_start" "', argument " "5"" of type '" "unsigned long""'");
29943 : }
29944 0 : arg5 = (unsigned long)(val5);
29945 0 : ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
29946 0 : if (!SWIG_IsOK(ecode6)) {
29947 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gpgme_op_createsubkey_start" "', argument " "6"" of type '" "unsigned int""'");
29948 : }
29949 0 : arg6 = (unsigned int)(val6);
29950 : {
29951 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
29952 0 : result = gpgme_op_createsubkey_start(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
29953 0 : SWIG_PYTHON_THREAD_END_ALLOW;
29954 : }
29955 : {
29956 0 : resultobj = PyLong_FromLong(result);
29957 : }
29958 : {
29959 0 : Py_XDECREF(encodedInput3);
29960 : }
29961 : return resultobj;
29962 : fail:
29963 : {
29964 0 : Py_XDECREF(encodedInput3);
29965 : }
29966 : return NULL;
29967 : }
29968 :
29969 :
29970 13 : SWIGINTERN PyObject *_wrap_gpgme_op_createsubkey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29971 13 : PyObject *resultobj = 0;
29972 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
29973 13 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
29974 13 : char *arg3 = (char *) 0 ;
29975 : unsigned long arg4 ;
29976 : unsigned long arg5 ;
29977 : unsigned int arg6 ;
29978 13 : void *argp1 = 0 ;
29979 13 : int res1 = 0 ;
29980 13 : void *argp2 = 0 ;
29981 13 : int res2 = 0 ;
29982 13 : PyObject *encodedInput3 = NULL ;
29983 : unsigned long val4 ;
29984 13 : int ecode4 = 0 ;
29985 : unsigned long val5 ;
29986 13 : int ecode5 = 0 ;
29987 : unsigned int val6 ;
29988 13 : int ecode6 = 0 ;
29989 13 : PyObject * obj0 = 0 ;
29990 13 : PyObject * obj1 = 0 ;
29991 13 : PyObject * obj2 = 0 ;
29992 13 : PyObject * obj3 = 0 ;
29993 13 : PyObject * obj4 = 0 ;
29994 13 : PyObject * obj5 = 0 ;
29995 : gpgme_error_t result;
29996 :
29997 13 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_createsubkey",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29998 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
29999 13 : if (!SWIG_IsOK(res1)) {
30000 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_createsubkey" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30001 : }
30002 13 : arg1 = (gpgme_ctx_t)(argp1);
30003 13 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30004 13 : if (!SWIG_IsOK(res2)) {
30005 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_createsubkey" "', argument " "2"" of type '" "gpgme_key_t""'");
30006 : }
30007 13 : arg2 = (gpgme_key_t)(argp2);
30008 : {
30009 13 : if (obj2 == Py_None)
30010 : arg3 = NULL;
30011 3 : else if (PyUnicode_Check(obj2))
30012 : {
30013 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30014 3 : if (encodedInput3 == NULL)
30015 : return NULL;
30016 3 : arg3 = PyBytes_AsString(encodedInput3);
30017 : }
30018 0 : else if (PyBytes_Check(obj2))
30019 0 : arg3 = PyBytes_AsString(obj2);
30020 : else {
30021 0 : PyErr_Format(PyExc_TypeError,
30022 : "arg %d: expected str, bytes, or None, got %s",
30023 : 3, obj2->ob_type->tp_name);
30024 0 : return NULL;
30025 : }
30026 : }
30027 13 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
30028 13 : if (!SWIG_IsOK(ecode4)) {
30029 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_createsubkey" "', argument " "4"" of type '" "unsigned long""'");
30030 : }
30031 13 : arg4 = (unsigned long)(val4);
30032 13 : ecode5 = SWIG_AsVal_unsigned_SS_long(obj4, &val5);
30033 13 : if (!SWIG_IsOK(ecode5)) {
30034 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_createsubkey" "', argument " "5"" of type '" "unsigned long""'");
30035 : }
30036 13 : arg5 = (unsigned long)(val5);
30037 26 : ecode6 = SWIG_AsVal_unsigned_SS_int(obj5, &val6);
30038 13 : if (!SWIG_IsOK(ecode6)) {
30039 0 : SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "gpgme_op_createsubkey" "', argument " "6"" of type '" "unsigned int""'");
30040 : }
30041 13 : arg6 = (unsigned int)(val6);
30042 : {
30043 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30044 13 : result = gpgme_op_createsubkey(arg1,arg2,(char const *)arg3,arg4,arg5,arg6);
30045 13 : SWIG_PYTHON_THREAD_END_ALLOW;
30046 : }
30047 : {
30048 13 : resultobj = PyLong_FromLong(result);
30049 : }
30050 : {
30051 13 : Py_XDECREF(encodedInput3);
30052 : }
30053 : return resultobj;
30054 : fail:
30055 : {
30056 0 : Py_XDECREF(encodedInput3);
30057 : }
30058 : return NULL;
30059 : }
30060 :
30061 :
30062 0 : SWIGINTERN PyObject *_wrap_gpgme_op_adduid_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30063 0 : PyObject *resultobj = 0;
30064 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30065 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30066 0 : char *arg3 = (char *) 0 ;
30067 : unsigned int arg4 ;
30068 0 : void *argp1 = 0 ;
30069 0 : int res1 = 0 ;
30070 0 : void *argp2 = 0 ;
30071 0 : int res2 = 0 ;
30072 0 : PyObject *encodedInput3 = NULL ;
30073 : unsigned int val4 ;
30074 0 : int ecode4 = 0 ;
30075 0 : PyObject * obj0 = 0 ;
30076 0 : PyObject * obj1 = 0 ;
30077 0 : PyObject * obj2 = 0 ;
30078 0 : PyObject * obj3 = 0 ;
30079 : gpgme_error_t result;
30080 :
30081 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_adduid_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30082 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30083 0 : if (!SWIG_IsOK(res1)) {
30084 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_adduid_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30085 : }
30086 0 : arg1 = (gpgme_ctx_t)(argp1);
30087 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30088 0 : if (!SWIG_IsOK(res2)) {
30089 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_adduid_start" "', argument " "2"" of type '" "gpgme_key_t""'");
30090 : }
30091 0 : arg2 = (gpgme_key_t)(argp2);
30092 : {
30093 0 : if (obj2 == Py_None)
30094 : arg3 = NULL;
30095 0 : else if (PyUnicode_Check(obj2))
30096 : {
30097 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30098 0 : if (encodedInput3 == NULL)
30099 : return NULL;
30100 0 : arg3 = PyBytes_AsString(encodedInput3);
30101 : }
30102 0 : else if (PyBytes_Check(obj2))
30103 0 : arg3 = PyBytes_AsString(obj2);
30104 : else {
30105 0 : PyErr_Format(PyExc_TypeError,
30106 : "arg %d: expected str, bytes, or None, got %s",
30107 : 3, obj2->ob_type->tp_name);
30108 0 : return NULL;
30109 : }
30110 : }
30111 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
30112 0 : if (!SWIG_IsOK(ecode4)) {
30113 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_adduid_start" "', argument " "4"" of type '" "unsigned int""'");
30114 : }
30115 0 : arg4 = (unsigned int)(val4);
30116 : {
30117 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30118 0 : result = gpgme_op_adduid_start(arg1,arg2,(char const *)arg3,arg4);
30119 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30120 : }
30121 : {
30122 0 : resultobj = PyLong_FromLong(result);
30123 : }
30124 : {
30125 0 : Py_XDECREF(encodedInput3);
30126 : }
30127 : return resultobj;
30128 : fail:
30129 : {
30130 0 : Py_XDECREF(encodedInput3);
30131 : }
30132 : return NULL;
30133 : }
30134 :
30135 :
30136 10 : SWIGINTERN PyObject *_wrap_gpgme_op_adduid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30137 10 : PyObject *resultobj = 0;
30138 10 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30139 10 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30140 10 : char *arg3 = (char *) 0 ;
30141 : unsigned int arg4 ;
30142 10 : void *argp1 = 0 ;
30143 10 : int res1 = 0 ;
30144 10 : void *argp2 = 0 ;
30145 10 : int res2 = 0 ;
30146 10 : PyObject *encodedInput3 = NULL ;
30147 : unsigned int val4 ;
30148 10 : int ecode4 = 0 ;
30149 10 : PyObject * obj0 = 0 ;
30150 10 : PyObject * obj1 = 0 ;
30151 10 : PyObject * obj2 = 0 ;
30152 10 : PyObject * obj3 = 0 ;
30153 : gpgme_error_t result;
30154 :
30155 10 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_adduid",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30156 10 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30157 10 : if (!SWIG_IsOK(res1)) {
30158 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_adduid" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30159 : }
30160 10 : arg1 = (gpgme_ctx_t)(argp1);
30161 10 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30162 10 : if (!SWIG_IsOK(res2)) {
30163 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_adduid" "', argument " "2"" of type '" "gpgme_key_t""'");
30164 : }
30165 10 : arg2 = (gpgme_key_t)(argp2);
30166 : {
30167 10 : if (obj2 == Py_None)
30168 : arg3 = NULL;
30169 10 : else if (PyUnicode_Check(obj2))
30170 : {
30171 10 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30172 10 : if (encodedInput3 == NULL)
30173 : return NULL;
30174 10 : arg3 = PyBytes_AsString(encodedInput3);
30175 : }
30176 0 : else if (PyBytes_Check(obj2))
30177 0 : arg3 = PyBytes_AsString(obj2);
30178 : else {
30179 0 : PyErr_Format(PyExc_TypeError,
30180 : "arg %d: expected str, bytes, or None, got %s",
30181 : 3, obj2->ob_type->tp_name);
30182 0 : return NULL;
30183 : }
30184 : }
30185 20 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
30186 10 : if (!SWIG_IsOK(ecode4)) {
30187 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_adduid" "', argument " "4"" of type '" "unsigned int""'");
30188 : }
30189 10 : arg4 = (unsigned int)(val4);
30190 : {
30191 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30192 10 : result = gpgme_op_adduid(arg1,arg2,(char const *)arg3,arg4);
30193 10 : SWIG_PYTHON_THREAD_END_ALLOW;
30194 : }
30195 : {
30196 10 : resultobj = PyLong_FromLong(result);
30197 : }
30198 : {
30199 10 : Py_XDECREF(encodedInput3);
30200 : }
30201 : return resultobj;
30202 : fail:
30203 : {
30204 0 : Py_XDECREF(encodedInput3);
30205 : }
30206 : return NULL;
30207 : }
30208 :
30209 :
30210 0 : SWIGINTERN PyObject *_wrap_gpgme_op_revuid_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30211 0 : PyObject *resultobj = 0;
30212 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30213 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30214 0 : char *arg3 = (char *) 0 ;
30215 : unsigned int arg4 ;
30216 0 : void *argp1 = 0 ;
30217 0 : int res1 = 0 ;
30218 0 : void *argp2 = 0 ;
30219 0 : int res2 = 0 ;
30220 0 : PyObject *encodedInput3 = NULL ;
30221 : unsigned int val4 ;
30222 0 : int ecode4 = 0 ;
30223 0 : PyObject * obj0 = 0 ;
30224 0 : PyObject * obj1 = 0 ;
30225 0 : PyObject * obj2 = 0 ;
30226 0 : PyObject * obj3 = 0 ;
30227 : gpgme_error_t result;
30228 :
30229 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_revuid_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30230 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30231 0 : if (!SWIG_IsOK(res1)) {
30232 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_revuid_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30233 : }
30234 0 : arg1 = (gpgme_ctx_t)(argp1);
30235 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30236 0 : if (!SWIG_IsOK(res2)) {
30237 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_revuid_start" "', argument " "2"" of type '" "gpgme_key_t""'");
30238 : }
30239 0 : arg2 = (gpgme_key_t)(argp2);
30240 : {
30241 0 : if (obj2 == Py_None)
30242 : arg3 = NULL;
30243 0 : else if (PyUnicode_Check(obj2))
30244 : {
30245 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30246 0 : if (encodedInput3 == NULL)
30247 : return NULL;
30248 0 : arg3 = PyBytes_AsString(encodedInput3);
30249 : }
30250 0 : else if (PyBytes_Check(obj2))
30251 0 : arg3 = PyBytes_AsString(obj2);
30252 : else {
30253 0 : PyErr_Format(PyExc_TypeError,
30254 : "arg %d: expected str, bytes, or None, got %s",
30255 : 3, obj2->ob_type->tp_name);
30256 0 : return NULL;
30257 : }
30258 : }
30259 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
30260 0 : if (!SWIG_IsOK(ecode4)) {
30261 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_revuid_start" "', argument " "4"" of type '" "unsigned int""'");
30262 : }
30263 0 : arg4 = (unsigned int)(val4);
30264 : {
30265 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30266 0 : result = gpgme_op_revuid_start(arg1,arg2,(char const *)arg3,arg4);
30267 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30268 : }
30269 : {
30270 0 : resultobj = PyLong_FromLong(result);
30271 : }
30272 : {
30273 0 : Py_XDECREF(encodedInput3);
30274 : }
30275 : return resultobj;
30276 : fail:
30277 : {
30278 0 : Py_XDECREF(encodedInput3);
30279 : }
30280 : return NULL;
30281 : }
30282 :
30283 :
30284 3 : SWIGINTERN PyObject *_wrap_gpgme_op_revuid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30285 3 : PyObject *resultobj = 0;
30286 3 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30287 3 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30288 3 : char *arg3 = (char *) 0 ;
30289 : unsigned int arg4 ;
30290 3 : void *argp1 = 0 ;
30291 3 : int res1 = 0 ;
30292 3 : void *argp2 = 0 ;
30293 3 : int res2 = 0 ;
30294 3 : PyObject *encodedInput3 = NULL ;
30295 : unsigned int val4 ;
30296 3 : int ecode4 = 0 ;
30297 3 : PyObject * obj0 = 0 ;
30298 3 : PyObject * obj1 = 0 ;
30299 3 : PyObject * obj2 = 0 ;
30300 3 : PyObject * obj3 = 0 ;
30301 : gpgme_error_t result;
30302 :
30303 3 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_revuid",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30304 3 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30305 3 : if (!SWIG_IsOK(res1)) {
30306 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_revuid" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30307 : }
30308 3 : arg1 = (gpgme_ctx_t)(argp1);
30309 3 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30310 3 : if (!SWIG_IsOK(res2)) {
30311 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_revuid" "', argument " "2"" of type '" "gpgme_key_t""'");
30312 : }
30313 3 : arg2 = (gpgme_key_t)(argp2);
30314 : {
30315 3 : if (obj2 == Py_None)
30316 : arg3 = NULL;
30317 3 : else if (PyUnicode_Check(obj2))
30318 : {
30319 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30320 3 : if (encodedInput3 == NULL)
30321 : return NULL;
30322 3 : arg3 = PyBytes_AsString(encodedInput3);
30323 : }
30324 0 : else if (PyBytes_Check(obj2))
30325 0 : arg3 = PyBytes_AsString(obj2);
30326 : else {
30327 0 : PyErr_Format(PyExc_TypeError,
30328 : "arg %d: expected str, bytes, or None, got %s",
30329 : 3, obj2->ob_type->tp_name);
30330 0 : return NULL;
30331 : }
30332 : }
30333 6 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
30334 3 : if (!SWIG_IsOK(ecode4)) {
30335 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_revuid" "', argument " "4"" of type '" "unsigned int""'");
30336 : }
30337 3 : arg4 = (unsigned int)(val4);
30338 : {
30339 3 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30340 3 : result = gpgme_op_revuid(arg1,arg2,(char const *)arg3,arg4);
30341 3 : SWIG_PYTHON_THREAD_END_ALLOW;
30342 : }
30343 : {
30344 3 : resultobj = PyLong_FromLong(result);
30345 : }
30346 : {
30347 3 : Py_XDECREF(encodedInput3);
30348 : }
30349 : return resultobj;
30350 : fail:
30351 : {
30352 0 : Py_XDECREF(encodedInput3);
30353 : }
30354 : return NULL;
30355 : }
30356 :
30357 :
30358 36 : SWIGINTERN PyObject *_wrap_gpgme_op_genkey_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30359 36 : PyObject *resultobj = 0;
30360 36 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30361 36 : void *argp1 = 0 ;
30362 36 : int res1 = 0 ;
30363 36 : PyObject * obj0 = 0 ;
30364 : gpgme_genkey_result_t result;
30365 :
30366 36 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_genkey_result",&obj0)) SWIG_fail;
30367 36 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30368 36 : if (!SWIG_IsOK(res1)) {
30369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_genkey_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30370 : }
30371 36 : arg1 = (gpgme_ctx_t)(argp1);
30372 : {
30373 36 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30374 36 : result = (gpgme_genkey_result_t)gpgme_op_genkey_result(arg1);
30375 36 : SWIG_PYTHON_THREAD_END_ALLOW;
30376 : }
30377 : {
30378 : PyObject *fragile;
30379 36 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_genkey_result,
30380 : 0 );
30381 36 : resultobj = _gpg_wrap_result(fragile, "GenkeyResult");
30382 36 : Py_DECREF(fragile);
30383 : }
30384 : return resultobj;
30385 : fail:
30386 : return NULL;
30387 : }
30388 :
30389 :
30390 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30391 0 : PyObject *resultobj = 0;
30392 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30393 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
30394 : int arg3 ;
30395 0 : void *argp1 = 0 ;
30396 0 : int res1 = 0 ;
30397 0 : void *argp2 = 0 ;
30398 0 : int res2 = 0 ;
30399 : int val3 ;
30400 0 : int ecode3 = 0 ;
30401 0 : PyObject * obj0 = 0 ;
30402 0 : PyObject * obj1 = 0 ;
30403 0 : PyObject * obj2 = 0 ;
30404 : gpgme_error_t result;
30405 :
30406 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete_start",&obj0,&obj1,&obj2)) SWIG_fail;
30407 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30408 0 : if (!SWIG_IsOK(res1)) {
30409 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30410 : }
30411 0 : arg1 = (gpgme_ctx_t)(argp1);
30412 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30413 0 : if (!SWIG_IsOK(res2)) {
30414 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete_start" "', argument " "2"" of type '" "gpgme_key_t const""'");
30415 : }
30416 0 : arg2 = (gpgme_key_t)(argp2);
30417 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
30418 0 : if (!SWIG_IsOK(ecode3)) {
30419 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete_start" "', argument " "3"" of type '" "int""'");
30420 : }
30421 0 : arg3 = (int)(val3);
30422 : {
30423 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30424 0 : result = gpgme_op_delete_start(arg1,arg2,arg3);
30425 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30426 : }
30427 : {
30428 0 : resultobj = PyLong_FromLong(result);
30429 : }
30430 0 : return resultobj;
30431 : fail:
30432 : return NULL;
30433 : }
30434 :
30435 :
30436 0 : SWIGINTERN PyObject *_wrap_gpgme_op_delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30437 0 : PyObject *resultobj = 0;
30438 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30439 0 : gpgme_key_t arg2 = (gpgme_key_t) (gpgme_key_t)0 ;
30440 : int arg3 ;
30441 0 : void *argp1 = 0 ;
30442 0 : int res1 = 0 ;
30443 0 : void *argp2 = 0 ;
30444 0 : int res2 = 0 ;
30445 : int val3 ;
30446 0 : int ecode3 = 0 ;
30447 0 : PyObject * obj0 = 0 ;
30448 0 : PyObject * obj1 = 0 ;
30449 0 : PyObject * obj2 = 0 ;
30450 : gpgme_error_t result;
30451 :
30452 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_delete",&obj0,&obj1,&obj2)) SWIG_fail;
30453 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30454 0 : if (!SWIG_IsOK(res1)) {
30455 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_delete" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30456 : }
30457 0 : arg1 = (gpgme_ctx_t)(argp1);
30458 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30459 0 : if (!SWIG_IsOK(res2)) {
30460 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_delete" "', argument " "2"" of type '" "gpgme_key_t const""'");
30461 : }
30462 0 : arg2 = (gpgme_key_t)(argp2);
30463 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
30464 0 : if (!SWIG_IsOK(ecode3)) {
30465 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_delete" "', argument " "3"" of type '" "int""'");
30466 : }
30467 0 : arg3 = (int)(val3);
30468 : {
30469 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30470 0 : result = gpgme_op_delete(arg1,arg2,arg3);
30471 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30472 : }
30473 : {
30474 0 : resultobj = PyLong_FromLong(result);
30475 : }
30476 0 : return resultobj;
30477 : fail:
30478 : return NULL;
30479 : }
30480 :
30481 :
30482 0 : SWIGINTERN PyObject *_wrap_gpgme_op_keysign_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30483 0 : PyObject *resultobj = 0;
30484 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30485 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30486 0 : char *arg3 = (char *) 0 ;
30487 : unsigned long arg4 ;
30488 : unsigned int arg5 ;
30489 0 : void *argp1 = 0 ;
30490 0 : int res1 = 0 ;
30491 0 : void *argp2 = 0 ;
30492 0 : int res2 = 0 ;
30493 0 : PyObject *encodedInput3 = NULL ;
30494 : unsigned long val4 ;
30495 0 : int ecode4 = 0 ;
30496 : unsigned int val5 ;
30497 0 : int ecode5 = 0 ;
30498 0 : PyObject * obj0 = 0 ;
30499 0 : PyObject * obj1 = 0 ;
30500 0 : PyObject * obj2 = 0 ;
30501 0 : PyObject * obj3 = 0 ;
30502 0 : PyObject * obj4 = 0 ;
30503 : gpgme_error_t result;
30504 :
30505 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_keysign_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30506 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30507 0 : if (!SWIG_IsOK(res1)) {
30508 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keysign_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30509 : }
30510 0 : arg1 = (gpgme_ctx_t)(argp1);
30511 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30512 0 : if (!SWIG_IsOK(res2)) {
30513 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keysign_start" "', argument " "2"" of type '" "gpgme_key_t""'");
30514 : }
30515 0 : arg2 = (gpgme_key_t)(argp2);
30516 : {
30517 0 : if (obj2 == Py_None)
30518 : arg3 = NULL;
30519 0 : else if (PyUnicode_Check(obj2))
30520 : {
30521 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30522 0 : if (encodedInput3 == NULL)
30523 : return NULL;
30524 0 : arg3 = PyBytes_AsString(encodedInput3);
30525 : }
30526 0 : else if (PyBytes_Check(obj2))
30527 0 : arg3 = PyBytes_AsString(obj2);
30528 : else {
30529 0 : PyErr_Format(PyExc_TypeError,
30530 : "arg %d: expected str, bytes, or None, got %s",
30531 : 3, obj2->ob_type->tp_name);
30532 0 : return NULL;
30533 : }
30534 : }
30535 0 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
30536 0 : if (!SWIG_IsOK(ecode4)) {
30537 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keysign_start" "', argument " "4"" of type '" "unsigned long""'");
30538 : }
30539 0 : arg4 = (unsigned long)(val4);
30540 0 : ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
30541 0 : if (!SWIG_IsOK(ecode5)) {
30542 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_keysign_start" "', argument " "5"" of type '" "unsigned int""'");
30543 : }
30544 0 : arg5 = (unsigned int)(val5);
30545 : {
30546 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30547 0 : result = gpgme_op_keysign_start(arg1,arg2,(char const *)arg3,arg4,arg5);
30548 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30549 : }
30550 : {
30551 0 : resultobj = PyLong_FromLong(result);
30552 : }
30553 : {
30554 0 : Py_XDECREF(encodedInput3);
30555 : }
30556 : return resultobj;
30557 : fail:
30558 : {
30559 0 : Py_XDECREF(encodedInput3);
30560 : }
30561 : return NULL;
30562 : }
30563 :
30564 :
30565 4 : SWIGINTERN PyObject *_wrap_gpgme_op_keysign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30566 4 : PyObject *resultobj = 0;
30567 4 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30568 4 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30569 4 : char *arg3 = (char *) 0 ;
30570 : unsigned long arg4 ;
30571 : unsigned int arg5 ;
30572 4 : void *argp1 = 0 ;
30573 4 : int res1 = 0 ;
30574 4 : void *argp2 = 0 ;
30575 4 : int res2 = 0 ;
30576 4 : PyObject *encodedInput3 = NULL ;
30577 : unsigned long val4 ;
30578 4 : int ecode4 = 0 ;
30579 : unsigned int val5 ;
30580 4 : int ecode5 = 0 ;
30581 4 : PyObject * obj0 = 0 ;
30582 4 : PyObject * obj1 = 0 ;
30583 4 : PyObject * obj2 = 0 ;
30584 4 : PyObject * obj3 = 0 ;
30585 4 : PyObject * obj4 = 0 ;
30586 : gpgme_error_t result;
30587 :
30588 4 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_keysign",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30589 4 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30590 4 : if (!SWIG_IsOK(res1)) {
30591 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keysign" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30592 : }
30593 4 : arg1 = (gpgme_ctx_t)(argp1);
30594 4 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30595 4 : if (!SWIG_IsOK(res2)) {
30596 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keysign" "', argument " "2"" of type '" "gpgme_key_t""'");
30597 : }
30598 4 : arg2 = (gpgme_key_t)(argp2);
30599 : {
30600 4 : if (obj2 == Py_None)
30601 : arg3 = NULL;
30602 3 : else if (PyUnicode_Check(obj2))
30603 : {
30604 3 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
30605 3 : if (encodedInput3 == NULL)
30606 : return NULL;
30607 3 : arg3 = PyBytes_AsString(encodedInput3);
30608 : }
30609 0 : else if (PyBytes_Check(obj2))
30610 0 : arg3 = PyBytes_AsString(obj2);
30611 : else {
30612 0 : PyErr_Format(PyExc_TypeError,
30613 : "arg %d: expected str, bytes, or None, got %s",
30614 : 3, obj2->ob_type->tp_name);
30615 0 : return NULL;
30616 : }
30617 : }
30618 4 : ecode4 = SWIG_AsVal_unsigned_SS_long(obj3, &val4);
30619 4 : if (!SWIG_IsOK(ecode4)) {
30620 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keysign" "', argument " "4"" of type '" "unsigned long""'");
30621 : }
30622 4 : arg4 = (unsigned long)(val4);
30623 8 : ecode5 = SWIG_AsVal_unsigned_SS_int(obj4, &val5);
30624 4 : if (!SWIG_IsOK(ecode5)) {
30625 0 : SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "gpgme_op_keysign" "', argument " "5"" of type '" "unsigned int""'");
30626 : }
30627 4 : arg5 = (unsigned int)(val5);
30628 : {
30629 4 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30630 4 : result = gpgme_op_keysign(arg1,arg2,(char const *)arg3,arg4,arg5);
30631 4 : SWIG_PYTHON_THREAD_END_ALLOW;
30632 : }
30633 : {
30634 4 : resultobj = PyLong_FromLong(result);
30635 : }
30636 : {
30637 4 : Py_XDECREF(encodedInput3);
30638 : }
30639 : return resultobj;
30640 : fail:
30641 : {
30642 0 : Py_XDECREF(encodedInput3);
30643 : }
30644 : return NULL;
30645 : }
30646 :
30647 :
30648 0 : SWIGINTERN PyObject *_wrap_gpgme_op_interact_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30649 0 : PyObject *resultobj = 0;
30650 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30651 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30652 : unsigned int arg3 ;
30653 0 : gpgme_interact_cb_t arg4 = (gpgme_interact_cb_t) 0 ;
30654 0 : void *arg5 = (void *) 0 ;
30655 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
30656 0 : void *argp1 = 0 ;
30657 0 : int res1 = 0 ;
30658 0 : void *argp2 = 0 ;
30659 0 : int res2 = 0 ;
30660 : unsigned int val3 ;
30661 0 : int ecode3 = 0 ;
30662 0 : gpgme_data_t wrapper6 = NULL ;
30663 0 : PyObject *bytesio6 = NULL ;
30664 : Py_buffer view6 ;
30665 0 : int have_view6 = 0 ;
30666 0 : PyObject * obj0 = 0 ;
30667 0 : PyObject * obj1 = 0 ;
30668 0 : PyObject * obj2 = 0 ;
30669 0 : PyObject * obj3 = 0 ;
30670 0 : PyObject * obj4 = 0 ;
30671 : gpgme_error_t result;
30672 :
30673 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_interact_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30674 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30675 0 : if (!SWIG_IsOK(res1)) {
30676 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_interact_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30677 : }
30678 0 : arg1 = (gpgme_ctx_t)(argp1);
30679 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30680 0 : if (!SWIG_IsOK(res2)) {
30681 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_interact_start" "', argument " "2"" of type '" "gpgme_key_t""'");
30682 : }
30683 0 : arg2 = (gpgme_key_t)(argp2);
30684 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
30685 0 : if (!SWIG_IsOK(ecode3)) {
30686 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_interact_start" "', argument " "3"" of type '" "unsigned int""'");
30687 : }
30688 0 : arg3 = (unsigned int)(val3);
30689 : {
30690 0 : if (! PyTuple_Check(obj3))
30691 0 : return PyErr_Format(PyExc_TypeError, "interact callback must be a tuple");
30692 0 : if (PyTuple_Size(obj3) != 2 && PyTuple_Size(obj3) != 3)
30693 0 : return PyErr_Format(PyExc_TypeError,
30694 : "interact callback must be a tuple of size 2 or 3");
30695 :
30696 0 : arg4 = (gpgme_interact_cb_t) _gpg_interact_cb;
30697 0 : arg5 = obj3;
30698 : }
30699 : {
30700 : /* If we create a temporary wrapper6 object, we will store it in
30701 : wrapperN, where N is 6. Here in this fragment, SWIG will
30702 : automatically append 6. */
30703 0 : memset(&view6, 0, sizeof view6);
30704 0 : if (obj4 == Py_None)
30705 0 : arg6 = NULL;
30706 : else {
30707 : PyObject *pypointer;
30708 0 : pypointer = _gpg_obj2gpgme_data_t(obj4, 6, &wrapper6,
30709 : &bytesio6, &view6);
30710 0 : if (pypointer == NULL)
30711 : return NULL;
30712 0 : have_view6 = !! view6.obj;
30713 :
30714 : /* input = obj4, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
30715 :
30716 : /* Following code is from swig's python.swg. */
30717 :
30718 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
30719 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
30720 0 : Py_DECREF(pypointer);
30721 : return NULL;
30722 : }
30723 0 : Py_DECREF(pypointer);
30724 : }
30725 : }
30726 : {
30727 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
30728 0 : result = gpgme_op_interact_start(arg1,arg2,arg3,arg4,arg5,arg6);
30729 0 : SWIG_PYTHON_THREAD_END_ALLOW;
30730 : }
30731 : {
30732 0 : resultobj = PyLong_FromLong(result);
30733 : }
30734 : {
30735 : /* See whether we need to update the Python buffer. */
30736 0 : if (resultobj && wrapper6 && view6.buf)
30737 : {
30738 : int dirty;
30739 0 : char *new_data = NULL;
30740 : size_t new_size;
30741 :
30742 :
30743 0 : new_data = wrapper6->data.mem.buffer;
30744 0 : new_size = wrapper6->data.mem.length;
30745 0 : dirty = new_data != NULL;
30746 :
30747 :
30748 :
30749 :
30750 :
30751 :
30752 :
30753 0 : if (dirty)
30754 : {
30755 : /* The buffer is dirty. */
30756 0 : if (view6.readonly)
30757 : {
30758 0 : Py_XDECREF(resultobj);
30759 0 : resultobj = NULL;
30760 0 : PyErr_SetString(PyExc_ValueError,
30761 : "cannot update read-only buffer");
30762 : }
30763 :
30764 : /* See if we need to truncate the buffer. */
30765 0 : if (resultobj && view6.len != new_size)
30766 : {
30767 0 : if (bytesio6 == NULL)
30768 : {
30769 0 : Py_XDECREF(resultobj);
30770 0 : resultobj = NULL;
30771 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30772 : }
30773 : else
30774 : {
30775 : PyObject *retval;
30776 0 : PyBuffer_Release(&view6);
30777 : assert(view6.obj == NULL);
30778 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
30779 : "l", (long) new_size);
30780 0 : if (retval == NULL)
30781 : {
30782 0 : Py_XDECREF(resultobj);
30783 : resultobj = NULL;
30784 : }
30785 : else
30786 : {
30787 0 : Py_DECREF(retval);
30788 :
30789 0 : retval = PyObject_CallMethod(bytesio6,
30790 : "getbuffer", NULL);
30791 0 : if (retval == NULL
30792 0 : || PyObject_GetBuffer(retval, &view6,
30793 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30794 : {
30795 0 : Py_XDECREF(resultobj);
30796 : resultobj = NULL;
30797 : }
30798 :
30799 0 : Py_XDECREF(retval);
30800 :
30801 0 : if (resultobj && view6.len
30802 : != new_size)
30803 : {
30804 0 : Py_XDECREF(resultobj);
30805 0 : resultobj = NULL;
30806 0 : PyErr_Format(PyExc_ValueError,
30807 : "Expected buffer of length %zu, got %zi",
30808 : new_size,
30809 : view6.len);
30810 : }
30811 : }
30812 : }
30813 : }
30814 0 : if (resultobj)
30815 0 : memcpy(view6.buf, new_data, new_size);
30816 : }
30817 :
30818 :
30819 :
30820 : }
30821 :
30822 : /* Free the temporary wrapper, if any. */
30823 0 : if (wrapper6)
30824 0 : gpgme_data_release(wrapper6);
30825 0 : Py_XDECREF (bytesio6);
30826 0 : if (have_view6 && view6.buf)
30827 0 : PyBuffer_Release(&view6);
30828 : }
30829 : return resultobj;
30830 : fail:
30831 : {
30832 : /* See whether we need to update the Python buffer. */
30833 : if (resultobj && wrapper6 && view6.buf)
30834 : {
30835 : int dirty;
30836 : char *new_data = NULL;
30837 : size_t new_size;
30838 :
30839 :
30840 : new_data = wrapper6->data.mem.buffer;
30841 : new_size = wrapper6->data.mem.length;
30842 : dirty = new_data != NULL;
30843 :
30844 :
30845 :
30846 :
30847 :
30848 :
30849 :
30850 : if (dirty)
30851 : {
30852 : /* The buffer is dirty. */
30853 : if (view6.readonly)
30854 : {
30855 : Py_XDECREF(resultobj);
30856 : resultobj = NULL;
30857 : PyErr_SetString(PyExc_ValueError,
30858 : "cannot update read-only buffer");
30859 : }
30860 :
30861 : /* See if we need to truncate the buffer. */
30862 : if (resultobj && view6.len != new_size)
30863 : {
30864 : if (bytesio6 == NULL)
30865 : {
30866 : Py_XDECREF(resultobj);
30867 : resultobj = NULL;
30868 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
30869 : }
30870 : else
30871 : {
30872 : PyObject *retval;
30873 : PyBuffer_Release(&view6);
30874 : assert(view6.obj == NULL);
30875 : retval = PyObject_CallMethod(bytesio6, "truncate",
30876 : "l", (long) new_size);
30877 : if (retval == NULL)
30878 : {
30879 : Py_XDECREF(resultobj);
30880 : resultobj = NULL;
30881 : }
30882 : else
30883 : {
30884 : Py_DECREF(retval);
30885 :
30886 : retval = PyObject_CallMethod(bytesio6,
30887 : "getbuffer", NULL);
30888 : if (retval == NULL
30889 : || PyObject_GetBuffer(retval, &view6,
30890 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
30891 : {
30892 : Py_XDECREF(resultobj);
30893 : resultobj = NULL;
30894 : }
30895 :
30896 : Py_XDECREF(retval);
30897 :
30898 : if (resultobj && view6.len
30899 : != new_size)
30900 : {
30901 : Py_XDECREF(resultobj);
30902 : resultobj = NULL;
30903 : PyErr_Format(PyExc_ValueError,
30904 : "Expected buffer of length %zu, got %zi",
30905 : new_size,
30906 : view6.len);
30907 : }
30908 : }
30909 : }
30910 : }
30911 : if (resultobj)
30912 : memcpy(view6.buf, new_data, new_size);
30913 : }
30914 :
30915 :
30916 :
30917 : }
30918 :
30919 : /* Free the temporary wrapper, if any. */
30920 0 : if (wrapper6)
30921 0 : gpgme_data_release(wrapper6);
30922 0 : Py_XDECREF (bytesio6);
30923 : if (have_view6 && view6.buf)
30924 : PyBuffer_Release(&view6);
30925 : }
30926 : return NULL;
30927 : }
30928 :
30929 :
30930 5 : SWIGINTERN PyObject *_wrap_gpgme_op_interact(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30931 5 : PyObject *resultobj = 0;
30932 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
30933 5 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
30934 : unsigned int arg3 ;
30935 5 : gpgme_interact_cb_t arg4 = (gpgme_interact_cb_t) 0 ;
30936 5 : void *arg5 = (void *) 0 ;
30937 5 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
30938 5 : void *argp1 = 0 ;
30939 5 : int res1 = 0 ;
30940 5 : void *argp2 = 0 ;
30941 5 : int res2 = 0 ;
30942 : unsigned int val3 ;
30943 5 : int ecode3 = 0 ;
30944 5 : gpgme_data_t wrapper6 = NULL ;
30945 5 : PyObject *bytesio6 = NULL ;
30946 : Py_buffer view6 ;
30947 5 : int have_view6 = 0 ;
30948 5 : PyObject * obj0 = 0 ;
30949 5 : PyObject * obj1 = 0 ;
30950 5 : PyObject * obj2 = 0 ;
30951 5 : PyObject * obj3 = 0 ;
30952 5 : PyObject * obj4 = 0 ;
30953 : gpgme_error_t result;
30954 :
30955 5 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_interact",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
30956 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
30957 5 : if (!SWIG_IsOK(res1)) {
30958 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_interact" "', argument " "1"" of type '" "gpgme_ctx_t""'");
30959 : }
30960 5 : arg1 = (gpgme_ctx_t)(argp1);
30961 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
30962 5 : if (!SWIG_IsOK(res2)) {
30963 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_interact" "', argument " "2"" of type '" "gpgme_key_t""'");
30964 : }
30965 5 : arg2 = (gpgme_key_t)(argp2);
30966 10 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
30967 5 : if (!SWIG_IsOK(ecode3)) {
30968 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_interact" "', argument " "3"" of type '" "unsigned int""'");
30969 : }
30970 5 : arg3 = (unsigned int)(val3);
30971 : {
30972 5 : if (! PyTuple_Check(obj3))
30973 0 : return PyErr_Format(PyExc_TypeError, "interact callback must be a tuple");
30974 5 : if (PyTuple_Size(obj3) != 2 && PyTuple_Size(obj3) != 3)
30975 0 : return PyErr_Format(PyExc_TypeError,
30976 : "interact callback must be a tuple of size 2 or 3");
30977 :
30978 5 : arg4 = (gpgme_interact_cb_t) _gpg_interact_cb;
30979 5 : arg5 = obj3;
30980 : }
30981 : {
30982 : /* If we create a temporary wrapper6 object, we will store it in
30983 : wrapperN, where N is 6. Here in this fragment, SWIG will
30984 : automatically append 6. */
30985 5 : memset(&view6, 0, sizeof view6);
30986 5 : if (obj4 == Py_None)
30987 0 : arg6 = NULL;
30988 : else {
30989 : PyObject *pypointer;
30990 5 : pypointer = _gpg_obj2gpgme_data_t(obj4, 6, &wrapper6,
30991 : &bytesio6, &view6);
30992 5 : if (pypointer == NULL)
30993 : return NULL;
30994 5 : have_view6 = !! view6.obj;
30995 :
30996 : /* input = obj4, 1 = arg6, 1_descriptor = SWIGTYPE_p_gpgme_data */
30997 :
30998 : /* Following code is from swig's python.swg. */
30999 :
31000 5 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg6, SWIGTYPE_p_gpgme_data,
31001 : SWIG_POINTER_EXCEPTION | 0 )) == -1) {
31002 0 : Py_DECREF(pypointer);
31003 : return NULL;
31004 : }
31005 5 : Py_DECREF(pypointer);
31006 : }
31007 : }
31008 : {
31009 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31010 5 : result = gpgme_op_interact(arg1,arg2,arg3,arg4,arg5,arg6);
31011 5 : SWIG_PYTHON_THREAD_END_ALLOW;
31012 : }
31013 : {
31014 5 : resultobj = PyLong_FromLong(result);
31015 : }
31016 : {
31017 : /* See whether we need to update the Python buffer. */
31018 5 : if (resultobj && wrapper6 && view6.buf)
31019 : {
31020 : int dirty;
31021 0 : char *new_data = NULL;
31022 : size_t new_size;
31023 :
31024 :
31025 0 : new_data = wrapper6->data.mem.buffer;
31026 0 : new_size = wrapper6->data.mem.length;
31027 0 : dirty = new_data != NULL;
31028 :
31029 :
31030 :
31031 :
31032 :
31033 :
31034 :
31035 0 : if (dirty)
31036 : {
31037 : /* The buffer is dirty. */
31038 0 : if (view6.readonly)
31039 : {
31040 0 : Py_XDECREF(resultobj);
31041 0 : resultobj = NULL;
31042 0 : PyErr_SetString(PyExc_ValueError,
31043 : "cannot update read-only buffer");
31044 : }
31045 :
31046 : /* See if we need to truncate the buffer. */
31047 0 : if (resultobj && view6.len != new_size)
31048 : {
31049 0 : if (bytesio6 == NULL)
31050 : {
31051 0 : Py_XDECREF(resultobj);
31052 0 : resultobj = NULL;
31053 0 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31054 : }
31055 : else
31056 : {
31057 : PyObject *retval;
31058 0 : PyBuffer_Release(&view6);
31059 : assert(view6.obj == NULL);
31060 0 : retval = PyObject_CallMethod(bytesio6, "truncate",
31061 : "l", (long) new_size);
31062 0 : if (retval == NULL)
31063 : {
31064 0 : Py_XDECREF(resultobj);
31065 : resultobj = NULL;
31066 : }
31067 : else
31068 : {
31069 0 : Py_DECREF(retval);
31070 :
31071 0 : retval = PyObject_CallMethod(bytesio6,
31072 : "getbuffer", NULL);
31073 0 : if (retval == NULL
31074 0 : || PyObject_GetBuffer(retval, &view6,
31075 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31076 : {
31077 0 : Py_XDECREF(resultobj);
31078 : resultobj = NULL;
31079 : }
31080 :
31081 0 : Py_XDECREF(retval);
31082 :
31083 0 : if (resultobj && view6.len
31084 : != new_size)
31085 : {
31086 0 : Py_XDECREF(resultobj);
31087 0 : resultobj = NULL;
31088 0 : PyErr_Format(PyExc_ValueError,
31089 : "Expected buffer of length %zu, got %zi",
31090 : new_size,
31091 : view6.len);
31092 : }
31093 : }
31094 : }
31095 : }
31096 0 : if (resultobj)
31097 0 : memcpy(view6.buf, new_data, new_size);
31098 : }
31099 :
31100 :
31101 :
31102 : }
31103 :
31104 : /* Free the temporary wrapper, if any. */
31105 5 : if (wrapper6)
31106 0 : gpgme_data_release(wrapper6);
31107 5 : Py_XDECREF (bytesio6);
31108 5 : if (have_view6 && view6.buf)
31109 0 : PyBuffer_Release(&view6);
31110 : }
31111 : return resultobj;
31112 : fail:
31113 : {
31114 : /* See whether we need to update the Python buffer. */
31115 : if (resultobj && wrapper6 && view6.buf)
31116 : {
31117 : int dirty;
31118 : char *new_data = NULL;
31119 : size_t new_size;
31120 :
31121 :
31122 : new_data = wrapper6->data.mem.buffer;
31123 : new_size = wrapper6->data.mem.length;
31124 : dirty = new_data != NULL;
31125 :
31126 :
31127 :
31128 :
31129 :
31130 :
31131 :
31132 : if (dirty)
31133 : {
31134 : /* The buffer is dirty. */
31135 : if (view6.readonly)
31136 : {
31137 : Py_XDECREF(resultobj);
31138 : resultobj = NULL;
31139 : PyErr_SetString(PyExc_ValueError,
31140 : "cannot update read-only buffer");
31141 : }
31142 :
31143 : /* See if we need to truncate the buffer. */
31144 : if (resultobj && view6.len != new_size)
31145 : {
31146 : if (bytesio6 == NULL)
31147 : {
31148 : Py_XDECREF(resultobj);
31149 : resultobj = NULL;
31150 : PyErr_SetString(PyExc_ValueError, "cannot resize buffer");
31151 : }
31152 : else
31153 : {
31154 : PyObject *retval;
31155 : PyBuffer_Release(&view6);
31156 : assert(view6.obj == NULL);
31157 : retval = PyObject_CallMethod(bytesio6, "truncate",
31158 : "l", (long) new_size);
31159 : if (retval == NULL)
31160 : {
31161 : Py_XDECREF(resultobj);
31162 : resultobj = NULL;
31163 : }
31164 : else
31165 : {
31166 : Py_DECREF(retval);
31167 :
31168 : retval = PyObject_CallMethod(bytesio6,
31169 : "getbuffer", NULL);
31170 : if (retval == NULL
31171 : || PyObject_GetBuffer(retval, &view6,
31172 : PyBUF_SIMPLE|PyBUF_WRITABLE) < 0)
31173 : {
31174 : Py_XDECREF(resultobj);
31175 : resultobj = NULL;
31176 : }
31177 :
31178 : Py_XDECREF(retval);
31179 :
31180 : if (resultobj && view6.len
31181 : != new_size)
31182 : {
31183 : Py_XDECREF(resultobj);
31184 : resultobj = NULL;
31185 : PyErr_Format(PyExc_ValueError,
31186 : "Expected buffer of length %zu, got %zi",
31187 : new_size,
31188 : view6.len);
31189 : }
31190 : }
31191 : }
31192 : }
31193 : if (resultobj)
31194 : memcpy(view6.buf, new_data, new_size);
31195 : }
31196 :
31197 :
31198 :
31199 : }
31200 :
31201 : /* Free the temporary wrapper, if any. */
31202 0 : if (wrapper6)
31203 0 : gpgme_data_release(wrapper6);
31204 0 : Py_XDECREF (bytesio6);
31205 : if (have_view6 && view6.buf)
31206 : PyBuffer_Release(&view6);
31207 : }
31208 : return NULL;
31209 : }
31210 :
31211 :
31212 0 : SWIGINTERN PyObject *_wrap_gpgme_op_tofu_policy_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31213 0 : PyObject *resultobj = 0;
31214 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31215 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
31216 : gpgme_tofu_policy_t arg3 ;
31217 0 : void *argp1 = 0 ;
31218 0 : int res1 = 0 ;
31219 0 : void *argp2 = 0 ;
31220 0 : int res2 = 0 ;
31221 : int val3 ;
31222 0 : int ecode3 = 0 ;
31223 0 : PyObject * obj0 = 0 ;
31224 0 : PyObject * obj1 = 0 ;
31225 0 : PyObject * obj2 = 0 ;
31226 : gpgme_error_t result;
31227 :
31228 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_tofu_policy_start",&obj0,&obj1,&obj2)) SWIG_fail;
31229 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31230 0 : if (!SWIG_IsOK(res1)) {
31231 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_tofu_policy_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31232 : }
31233 0 : arg1 = (gpgme_ctx_t)(argp1);
31234 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
31235 0 : if (!SWIG_IsOK(res2)) {
31236 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_tofu_policy_start" "', argument " "2"" of type '" "gpgme_key_t""'");
31237 : }
31238 0 : arg2 = (gpgme_key_t)(argp2);
31239 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
31240 0 : if (!SWIG_IsOK(ecode3)) {
31241 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_tofu_policy_start" "', argument " "3"" of type '" "gpgme_tofu_policy_t""'");
31242 : }
31243 0 : arg3 = (gpgme_tofu_policy_t)(val3);
31244 : {
31245 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31246 0 : result = gpgme_op_tofu_policy_start(arg1,arg2,arg3);
31247 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31248 : }
31249 : {
31250 0 : resultobj = PyLong_FromLong(result);
31251 : }
31252 0 : return resultobj;
31253 : fail:
31254 : return NULL;
31255 : }
31256 :
31257 :
31258 5 : SWIGINTERN PyObject *_wrap_gpgme_op_tofu_policy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31259 5 : PyObject *resultobj = 0;
31260 5 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31261 5 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
31262 : gpgme_tofu_policy_t arg3 ;
31263 5 : void *argp1 = 0 ;
31264 5 : int res1 = 0 ;
31265 5 : void *argp2 = 0 ;
31266 5 : int res2 = 0 ;
31267 : int val3 ;
31268 5 : int ecode3 = 0 ;
31269 5 : PyObject * obj0 = 0 ;
31270 5 : PyObject * obj1 = 0 ;
31271 5 : PyObject * obj2 = 0 ;
31272 : gpgme_error_t result;
31273 :
31274 5 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_tofu_policy",&obj0,&obj1,&obj2)) SWIG_fail;
31275 5 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31276 5 : if (!SWIG_IsOK(res1)) {
31277 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_tofu_policy" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31278 : }
31279 5 : arg1 = (gpgme_ctx_t)(argp1);
31280 5 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
31281 5 : if (!SWIG_IsOK(res2)) {
31282 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_tofu_policy" "', argument " "2"" of type '" "gpgme_key_t""'");
31283 : }
31284 5 : arg2 = (gpgme_key_t)(argp2);
31285 10 : ecode3 = SWIG_AsVal_int(obj2, &val3);
31286 5 : if (!SWIG_IsOK(ecode3)) {
31287 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_tofu_policy" "', argument " "3"" of type '" "gpgme_tofu_policy_t""'");
31288 : }
31289 5 : arg3 = (gpgme_tofu_policy_t)(val3);
31290 : {
31291 5 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31292 5 : result = gpgme_op_tofu_policy(arg1,arg2,arg3);
31293 5 : SWIG_PYTHON_THREAD_END_ALLOW;
31294 : }
31295 : {
31296 5 : resultobj = PyLong_FromLong(result);
31297 : }
31298 5 : return resultobj;
31299 : fail:
31300 : return NULL;
31301 : }
31302 :
31303 :
31304 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31305 0 : PyObject *resultobj = 0;
31306 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
31307 : unsigned int arg2 ;
31308 0 : void *argp1 = 0 ;
31309 0 : int res1 = 0 ;
31310 : unsigned int val2 ;
31311 0 : int ecode2 = 0 ;
31312 0 : PyObject * obj0 = 0 ;
31313 0 : PyObject * obj1 = 0 ;
31314 :
31315 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_keylist_result_truncated_set",&obj0,&obj1)) SWIG_fail;
31316 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
31317 0 : if (!SWIG_IsOK(res1)) {
31318 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
31319 : }
31320 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
31321 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
31322 0 : if (!SWIG_IsOK(ecode2)) {
31323 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result_truncated_set" "', argument " "2"" of type '" "unsigned int""'");
31324 : }
31325 0 : arg2 = (unsigned int)(val2);
31326 : {
31327 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31328 0 : if (arg1) (arg1)->truncated = arg2;
31329 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31330 : }
31331 0 : resultobj = SWIG_Py_Void();
31332 0 : return resultobj;
31333 : fail:
31334 : return NULL;
31335 : }
31336 :
31337 :
31338 2 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result_truncated_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31339 2 : PyObject *resultobj = 0;
31340 2 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
31341 2 : void *argp1 = 0 ;
31342 2 : int res1 = 0 ;
31343 2 : PyObject * obj0 = 0 ;
31344 : unsigned int result;
31345 :
31346 2 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result_truncated_get",&obj0)) SWIG_fail;
31347 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
31348 2 : if (!SWIG_IsOK(res1)) {
31349 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result_truncated_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
31350 : }
31351 2 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
31352 : {
31353 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31354 2 : result = (unsigned int) ((arg1)->truncated);
31355 2 : SWIG_PYTHON_THREAD_END_ALLOW;
31356 : }
31357 2 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
31358 2 : return resultobj;
31359 : fail:
31360 : return NULL;
31361 : }
31362 :
31363 :
31364 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31365 0 : PyObject *resultobj = 0;
31366 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
31367 : unsigned int arg2 ;
31368 0 : void *argp1 = 0 ;
31369 0 : int res1 = 0 ;
31370 : unsigned int val2 ;
31371 0 : int ecode2 = 0 ;
31372 0 : PyObject * obj0 = 0 ;
31373 0 : PyObject * obj1 = 0 ;
31374 :
31375 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_keylist_result__unused_set",&obj0,&obj1)) SWIG_fail;
31376 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
31377 0 : if (!SWIG_IsOK(res1)) {
31378 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
31379 : }
31380 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
31381 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
31382 0 : if (!SWIG_IsOK(ecode2)) {
31383 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_keylist_result__unused_set" "', argument " "2"" of type '" "unsigned int""'");
31384 : }
31385 0 : arg2 = (unsigned int)(val2);
31386 : {
31387 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31388 0 : if (arg1) (arg1)->_unused = arg2;
31389 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31390 : }
31391 0 : resultobj = SWIG_Py_Void();
31392 0 : return resultobj;
31393 : fail:
31394 : return NULL;
31395 : }
31396 :
31397 :
31398 0 : SWIGINTERN PyObject *_wrap__gpgme_op_keylist_result__unused_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31399 0 : PyObject *resultobj = 0;
31400 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
31401 0 : void *argp1 = 0 ;
31402 0 : int res1 = 0 ;
31403 0 : PyObject * obj0 = 0 ;
31404 : unsigned int result;
31405 :
31406 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_keylist_result__unused_get",&obj0)) SWIG_fail;
31407 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, 0 | 0 );
31408 0 : if (!SWIG_IsOK(res1)) {
31409 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_keylist_result__unused_get" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
31410 : }
31411 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
31412 : {
31413 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31414 0 : result = (unsigned int) ((arg1)->_unused);
31415 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31416 : }
31417 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
31418 0 : return resultobj;
31419 : fail:
31420 : return NULL;
31421 : }
31422 :
31423 :
31424 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31425 0 : PyObject *resultobj = 0;
31426 0 : struct _gpgme_op_keylist_result *result = 0 ;
31427 :
31428 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_keylist_result")) SWIG_fail;
31429 : {
31430 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31431 0 : result = (struct _gpgme_op_keylist_result *)calloc(1, sizeof(struct _gpgme_op_keylist_result));
31432 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31433 : }
31434 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result, SWIG_POINTER_NEW | 0 );
31435 0 : return resultobj;
31436 : fail:
31437 : return NULL;
31438 : }
31439 :
31440 :
31441 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31442 0 : PyObject *resultobj = 0;
31443 0 : struct _gpgme_op_keylist_result *arg1 = (struct _gpgme_op_keylist_result *) 0 ;
31444 0 : void *argp1 = 0 ;
31445 0 : int res1 = 0 ;
31446 0 : PyObject * obj0 = 0 ;
31447 :
31448 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_keylist_result",&obj0)) SWIG_fail;
31449 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_keylist_result, SWIG_POINTER_DISOWN | 0 );
31450 0 : if (!SWIG_IsOK(res1)) {
31451 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_keylist_result" "', argument " "1"" of type '" "struct _gpgme_op_keylist_result *""'");
31452 : }
31453 0 : arg1 = (struct _gpgme_op_keylist_result *)(argp1);
31454 : {
31455 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31456 0 : free((char *) arg1);
31457 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31458 : }
31459 0 : resultobj = SWIG_Py_Void();
31460 0 : return resultobj;
31461 : fail:
31462 : return NULL;
31463 : }
31464 :
31465 :
31466 27 : SWIGINTERN PyObject *_gpgme_op_keylist_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31467 : PyObject *obj;
31468 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
31469 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_keylist_result, SWIG_NewClientData(obj));
31470 27 : return SWIG_Py_Void();
31471 : }
31472 :
31473 1 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 1 : PyObject *resultobj = 0;
31475 1 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31476 1 : void *argp1 = 0 ;
31477 1 : int res1 = 0 ;
31478 1 : PyObject * obj0 = 0 ;
31479 : gpgme_keylist_result_t result;
31480 :
31481 1 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_result",&obj0)) SWIG_fail;
31482 1 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31483 1 : if (!SWIG_IsOK(res1)) {
31484 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31485 : }
31486 1 : arg1 = (gpgme_ctx_t)(argp1);
31487 : {
31488 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31489 1 : result = (gpgme_keylist_result_t)gpgme_op_keylist_result(arg1);
31490 1 : SWIG_PYTHON_THREAD_END_ALLOW;
31491 : }
31492 : {
31493 : PyObject *fragile;
31494 1 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_keylist_result,
31495 : 0 );
31496 1 : resultobj = _gpg_wrap_result(fragile, "KeylistResult");
31497 1 : Py_DECREF(fragile);
31498 : }
31499 : return resultobj;
31500 : fail:
31501 : return NULL;
31502 : }
31503 :
31504 :
31505 0 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_ext_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31506 0 : PyObject *resultobj = 0;
31507 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31508 : char **arg2 ;
31509 : int arg3 ;
31510 : int arg4 ;
31511 0 : void *argp1 = 0 ;
31512 0 : int res1 = 0 ;
31513 0 : void *vector2 = NULL ;
31514 : size_t size2 ;
31515 0 : PyObject **pyVector2 = NULL ;
31516 : int val3 ;
31517 0 : int ecode3 = 0 ;
31518 : int val4 ;
31519 0 : int ecode4 = 0 ;
31520 0 : PyObject * obj0 = 0 ;
31521 0 : PyObject * obj1 = 0 ;
31522 0 : PyObject * obj2 = 0 ;
31523 0 : PyObject * obj3 = 0 ;
31524 : gpgme_error_t result;
31525 :
31526 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_keylist_ext_start",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31527 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31528 0 : if (!SWIG_IsOK(res1)) {
31529 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_ext_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31530 : }
31531 0 : arg1 = (gpgme_ctx_t)(argp1);
31532 : {
31533 : /* Check if is a list */
31534 0 : if (PyList_Check(obj1)) {
31535 : size_t i, j;
31536 0 : size2 = PyList_Size(obj1);
31537 0 : arg2 = (char **) (vector2 = malloc((size2+1) * sizeof(char *)));
31538 0 : pyVector2 = calloc(sizeof *pyVector2, size2);
31539 :
31540 0 : for (i = 0; i < size2; i++) {
31541 0 : PyObject *o = PyList_GetItem(obj1,i);
31542 0 : if (PyUnicode_Check(o))
31543 : {
31544 0 : pyVector2[i] = PyUnicode_AsUTF8String(o);
31545 0 : if (pyVector2[i] == NULL)
31546 : {
31547 0 : free(vector2);
31548 0 : for (j = 0; j < i; j++)
31549 0 : Py_XDECREF(pyVector2[j]);
31550 : return NULL;
31551 : }
31552 0 : arg2[i] = PyBytes_AsString(pyVector2[i]);
31553 : }
31554 0 : else if (PyString_Check(o))
31555 0 : arg2[i] = PyString_AsString(o);
31556 : else {
31557 0 : PyErr_Format(PyExc_TypeError,
31558 : "arg %d: list must contain only str or bytes, got %s "
31559 : "at position %d",
31560 : 2, o->ob_type->tp_name, i);
31561 0 : free(arg2);
31562 0 : return NULL;
31563 : }
31564 : }
31565 0 : arg2[i] = NULL;
31566 : } else {
31567 0 : PyErr_Format(PyExc_TypeError,
31568 : "arg %d: expected a list of str or bytes, got %s",
31569 : 2, obj1->ob_type->tp_name);
31570 0 : return NULL;
31571 : }
31572 : }
31573 0 : ecode3 = SWIG_AsVal_int(obj2, &val3);
31574 0 : if (!SWIG_IsOK(ecode3)) {
31575 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_keylist_ext_start" "', argument " "3"" of type '" "int""'");
31576 : }
31577 0 : arg3 = (int)(val3);
31578 0 : ecode4 = SWIG_AsVal_int(obj3, &val4);
31579 0 : if (!SWIG_IsOK(ecode4)) {
31580 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_keylist_ext_start" "', argument " "4"" of type '" "int""'");
31581 : }
31582 0 : arg4 = (int)(val4);
31583 : {
31584 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31585 0 : result = gpgme_op_keylist_ext_start(arg1,(char const *(*))arg2,arg3,arg4);
31586 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31587 : }
31588 : {
31589 0 : resultobj = PyLong_FromLong(result);
31590 : }
31591 : {
31592 : size_t i;
31593 0 : free(vector2);
31594 0 : for (i = 0; i < size2; i++)
31595 0 : Py_XDECREF(pyVector2[i]);
31596 : }
31597 : return resultobj;
31598 : fail:
31599 : {
31600 : size_t i;
31601 0 : free(vector2);
31602 0 : for (i = 0; i < size2; i++)
31603 0 : Py_XDECREF(pyVector2[i]);
31604 : }
31605 : return NULL;
31606 : }
31607 :
31608 :
31609 114 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31610 114 : PyObject *resultobj = 0;
31611 114 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31612 114 : gpgme_key_t *arg2 = (gpgme_key_t *) 0 ;
31613 114 : void *argp1 = 0 ;
31614 114 : int res1 = 0 ;
31615 114 : void *argp2 = 0 ;
31616 114 : int res2 = 0 ;
31617 114 : PyObject * obj0 = 0 ;
31618 114 : PyObject * obj1 = 0 ;
31619 : gpgme_error_t result;
31620 :
31621 114 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_keylist_next",&obj0,&obj1)) SWIG_fail;
31622 114 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31623 114 : if (!SWIG_IsOK(res1)) {
31624 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31625 : }
31626 114 : arg1 = (gpgme_ctx_t)(argp1);
31627 114 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
31628 114 : if (!SWIG_IsOK(res2)) {
31629 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_keylist_next" "', argument " "2"" of type '" "gpgme_key_t *""'");
31630 : }
31631 114 : arg2 = (gpgme_key_t *)(argp2);
31632 : {
31633 114 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31634 114 : result = gpgme_op_keylist_next(arg1,arg2);
31635 114 : SWIG_PYTHON_THREAD_END_ALLOW;
31636 : }
31637 : {
31638 114 : resultobj = PyLong_FromLong(result);
31639 : }
31640 114 : return resultobj;
31641 : fail:
31642 : return NULL;
31643 : }
31644 :
31645 :
31646 16 : SWIGINTERN PyObject *_wrap_gpgme_op_keylist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31647 16 : PyObject *resultobj = 0;
31648 16 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31649 16 : void *argp1 = 0 ;
31650 16 : int res1 = 0 ;
31651 16 : PyObject * obj0 = 0 ;
31652 : gpgme_error_t result;
31653 :
31654 16 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_keylist_end",&obj0)) SWIG_fail;
31655 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31656 16 : if (!SWIG_IsOK(res1)) {
31657 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_keylist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31658 : }
31659 16 : arg1 = (gpgme_ctx_t)(argp1);
31660 : {
31661 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31662 16 : result = gpgme_op_keylist_end(arg1);
31663 16 : SWIG_PYTHON_THREAD_END_ALLOW;
31664 : }
31665 : {
31666 16 : resultobj = PyLong_FromLong(result);
31667 : }
31668 16 : return resultobj;
31669 : fail:
31670 : return NULL;
31671 : }
31672 :
31673 :
31674 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31675 0 : PyObject *resultobj = 0;
31676 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31677 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
31678 : unsigned int arg3 ;
31679 0 : void *argp1 = 0 ;
31680 0 : int res1 = 0 ;
31681 0 : void *argp2 = 0 ;
31682 0 : int res2 = 0 ;
31683 : unsigned int val3 ;
31684 0 : int ecode3 = 0 ;
31685 0 : PyObject * obj0 = 0 ;
31686 0 : PyObject * obj1 = 0 ;
31687 0 : PyObject * obj2 = 0 ;
31688 : gpgme_error_t result;
31689 :
31690 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd_start",&obj0,&obj1,&obj2)) SWIG_fail;
31691 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31692 0 : if (!SWIG_IsOK(res1)) {
31693 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31694 : }
31695 0 : arg1 = (gpgme_ctx_t)(argp1);
31696 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
31697 0 : if (!SWIG_IsOK(res2)) {
31698 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd_start" "', argument " "2"" of type '" "gpgme_key_t""'");
31699 : }
31700 0 : arg2 = (gpgme_key_t)(argp2);
31701 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
31702 0 : if (!SWIG_IsOK(ecode3)) {
31703 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd_start" "', argument " "3"" of type '" "unsigned int""'");
31704 : }
31705 0 : arg3 = (unsigned int)(val3);
31706 : {
31707 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31708 0 : result = gpgme_op_passwd_start(arg1,arg2,arg3);
31709 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31710 : }
31711 : {
31712 0 : resultobj = PyLong_FromLong(result);
31713 : }
31714 0 : return resultobj;
31715 : fail:
31716 : return NULL;
31717 : }
31718 :
31719 :
31720 0 : SWIGINTERN PyObject *_wrap_gpgme_op_passwd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31721 0 : PyObject *resultobj = 0;
31722 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
31723 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
31724 : unsigned int arg3 ;
31725 0 : void *argp1 = 0 ;
31726 0 : int res1 = 0 ;
31727 0 : void *argp2 = 0 ;
31728 0 : int res2 = 0 ;
31729 : unsigned int val3 ;
31730 0 : int ecode3 = 0 ;
31731 0 : PyObject * obj0 = 0 ;
31732 0 : PyObject * obj1 = 0 ;
31733 0 : PyObject * obj2 = 0 ;
31734 : gpgme_error_t result;
31735 :
31736 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_passwd",&obj0,&obj1,&obj2)) SWIG_fail;
31737 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
31738 0 : if (!SWIG_IsOK(res1)) {
31739 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_passwd" "', argument " "1"" of type '" "gpgme_ctx_t""'");
31740 : }
31741 0 : arg1 = (gpgme_ctx_t)(argp1);
31742 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
31743 0 : if (!SWIG_IsOK(res2)) {
31744 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_passwd" "', argument " "2"" of type '" "gpgme_key_t""'");
31745 : }
31746 0 : arg2 = (gpgme_key_t)(argp2);
31747 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
31748 0 : if (!SWIG_IsOK(ecode3)) {
31749 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_passwd" "', argument " "3"" of type '" "unsigned int""'");
31750 : }
31751 0 : arg3 = (unsigned int)(val3);
31752 : {
31753 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31754 0 : result = gpgme_op_passwd(arg1,arg2,arg3);
31755 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31756 : }
31757 : {
31758 0 : resultobj = PyLong_FromLong(result);
31759 : }
31760 0 : return resultobj;
31761 : fail:
31762 : return NULL;
31763 : }
31764 :
31765 :
31766 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31767 0 : PyObject *resultobj = 0;
31768 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31769 : unsigned int arg2 ;
31770 0 : void *argp1 = 0 ;
31771 0 : int res1 = 0 ;
31772 : unsigned int val2 ;
31773 0 : int ecode2 = 0 ;
31774 0 : PyObject * obj0 = 0 ;
31775 0 : PyObject * obj1 = 0 ;
31776 :
31777 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__refs_set",&obj0,&obj1)) SWIG_fail;
31778 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31779 0 : if (!SWIG_IsOK(res1)) {
31780 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31781 : }
31782 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31783 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
31784 0 : if (!SWIG_IsOK(ecode2)) {
31785 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item__refs_set" "', argument " "2"" of type '" "unsigned int""'");
31786 : }
31787 0 : arg2 = (unsigned int)(val2);
31788 : {
31789 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31790 0 : if (arg1) (arg1)->_refs = arg2;
31791 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31792 : }
31793 0 : resultobj = SWIG_Py_Void();
31794 0 : return resultobj;
31795 : fail:
31796 : return NULL;
31797 : }
31798 :
31799 :
31800 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__refs_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31801 0 : PyObject *resultobj = 0;
31802 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31803 0 : void *argp1 = 0 ;
31804 0 : int res1 = 0 ;
31805 0 : PyObject * obj0 = 0 ;
31806 : unsigned int result;
31807 :
31808 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__refs_get",&obj0)) SWIG_fail;
31809 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31810 0 : if (!SWIG_IsOK(res1)) {
31811 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__refs_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31812 : }
31813 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31814 : {
31815 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31816 0 : result = (unsigned int) ((arg1)->_refs);
31817 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31818 : }
31819 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
31820 0 : return resultobj;
31821 : fail:
31822 : return NULL;
31823 : }
31824 :
31825 :
31826 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31827 0 : PyObject *resultobj = 0;
31828 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31829 0 : char *arg2 = (char *) 0 ;
31830 0 : void *argp1 = 0 ;
31831 0 : int res1 = 0 ;
31832 : int res2 ;
31833 0 : char *buf2 = 0 ;
31834 0 : int alloc2 = 0 ;
31835 0 : PyObject * obj0 = 0 ;
31836 0 : PyObject * obj1 = 0 ;
31837 :
31838 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_keyid_set",&obj0,&obj1)) SWIG_fail;
31839 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31840 0 : if (!SWIG_IsOK(res1)) {
31841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31842 : }
31843 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31844 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
31845 0 : if (!SWIG_IsOK(res2)) {
31846 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_keyid_set" "', argument " "2"" of type '" "char *""'");
31847 : }
31848 0 : arg2 = (char *)(buf2);
31849 : {
31850 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31851 0 : if (arg1->keyid) free((char*)arg1->keyid);
31852 0 : if (arg2) {
31853 0 : size_t size = strlen((const char *)(arg2)) + 1;
31854 0 : arg1->keyid = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
31855 : } else {
31856 0 : arg1->keyid = 0;
31857 : }
31858 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31859 : }
31860 0 : resultobj = SWIG_Py_Void();
31861 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31862 : return resultobj;
31863 : fail:
31864 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
31865 : return NULL;
31866 : }
31867 :
31868 :
31869 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31870 0 : PyObject *resultobj = 0;
31871 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31872 0 : void *argp1 = 0 ;
31873 0 : int res1 = 0 ;
31874 0 : PyObject * obj0 = 0 ;
31875 0 : char *result = 0 ;
31876 :
31877 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_keyid_get",&obj0)) SWIG_fail;
31878 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31879 0 : if (!SWIG_IsOK(res1)) {
31880 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31881 : }
31882 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31883 : {
31884 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31885 0 : result = (char *) ((arg1)->keyid);
31886 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31887 : }
31888 0 : resultobj = SWIG_FromCharPtr((const char *)result);
31889 0 : return resultobj;
31890 : fail:
31891 : return NULL;
31892 : }
31893 :
31894 :
31895 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31896 0 : PyObject *resultobj = 0;
31897 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31898 : char *arg2 ;
31899 0 : void *argp1 = 0 ;
31900 0 : int res1 = 0 ;
31901 : char temp2[16+1] ;
31902 : int res2 ;
31903 0 : PyObject * obj0 = 0 ;
31904 0 : PyObject * obj1 = 0 ;
31905 :
31906 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__keyid_set",&obj0,&obj1)) SWIG_fail;
31907 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31908 0 : if (!SWIG_IsOK(res1)) {
31909 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31910 : }
31911 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31912 0 : res2 = SWIG_AsCharArray(obj1, temp2, 16+1);
31913 0 : if (!SWIG_IsOK(res2)) {
31914 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__keyid_set" "', argument " "2"" of type '" "char [16+1]""'");
31915 : }
31916 0 : arg2 = (char *)(temp2);
31917 : {
31918 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31919 0 : if (arg2) memcpy(arg1->_keyid,arg2,16+1*sizeof(char));
31920 : else memset(arg1->_keyid,0,16+1*sizeof(char));
31921 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31922 : }
31923 0 : resultobj = SWIG_Py_Void();
31924 0 : return resultobj;
31925 : fail:
31926 : return NULL;
31927 : }
31928 :
31929 :
31930 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__keyid_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31931 0 : PyObject *resultobj = 0;
31932 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31933 0 : void *argp1 = 0 ;
31934 0 : int res1 = 0 ;
31935 0 : PyObject * obj0 = 0 ;
31936 0 : char *result = 0 ;
31937 :
31938 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__keyid_get",&obj0)) SWIG_fail;
31939 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31940 0 : if (!SWIG_IsOK(res1)) {
31941 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__keyid_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31942 : }
31943 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31944 : {
31945 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31946 0 : result = (char *)(char *) ((arg1)->_keyid);
31947 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31948 : }
31949 : {
31950 0 : size_t size = SWIG_strnlen(result, 16+1);
31951 :
31952 :
31953 :
31954 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
31955 : }
31956 0 : return resultobj;
31957 : fail:
31958 : return NULL;
31959 : }
31960 :
31961 :
31962 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31963 0 : PyObject *resultobj = 0;
31964 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31965 : int arg2 ;
31966 0 : void *argp1 = 0 ;
31967 0 : int res1 = 0 ;
31968 : int val2 ;
31969 0 : int ecode2 = 0 ;
31970 0 : PyObject * obj0 = 0 ;
31971 0 : PyObject * obj1 = 0 ;
31972 :
31973 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_type_set",&obj0,&obj1)) SWIG_fail;
31974 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
31975 0 : if (!SWIG_IsOK(res1)) {
31976 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
31977 : }
31978 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
31979 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
31980 0 : if (!SWIG_IsOK(ecode2)) {
31981 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_type_set" "', argument " "2"" of type '" "int""'");
31982 : }
31983 0 : arg2 = (int)(val2);
31984 : {
31985 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
31986 0 : if (arg1) (arg1)->type = arg2;
31987 0 : SWIG_PYTHON_THREAD_END_ALLOW;
31988 : }
31989 0 : resultobj = SWIG_Py_Void();
31990 0 : return resultobj;
31991 : fail:
31992 : return NULL;
31993 : }
31994 :
31995 :
31996 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31997 0 : PyObject *resultobj = 0;
31998 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
31999 0 : void *argp1 = 0 ;
32000 0 : int res1 = 0 ;
32001 0 : PyObject * obj0 = 0 ;
32002 : int result;
32003 :
32004 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_type_get",&obj0)) SWIG_fail;
32005 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32006 0 : if (!SWIG_IsOK(res1)) {
32007 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_type_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32008 : }
32009 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32010 : {
32011 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32012 0 : result = (int) ((arg1)->type);
32013 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32014 : }
32015 0 : resultobj = SWIG_From_int((int)(result));
32016 0 : return resultobj;
32017 : fail:
32018 : return NULL;
32019 : }
32020 :
32021 :
32022 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32023 0 : PyObject *resultobj = 0;
32024 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32025 : int arg2 ;
32026 0 : void *argp1 = 0 ;
32027 0 : int res1 = 0 ;
32028 : int val2 ;
32029 0 : int ecode2 = 0 ;
32030 0 : PyObject * obj0 = 0 ;
32031 0 : PyObject * obj1 = 0 ;
32032 :
32033 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_level_set",&obj0,&obj1)) SWIG_fail;
32034 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32035 0 : if (!SWIG_IsOK(res1)) {
32036 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32037 : }
32038 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32039 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
32040 0 : if (!SWIG_IsOK(ecode2)) {
32041 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_trust_item_level_set" "', argument " "2"" of type '" "int""'");
32042 : }
32043 0 : arg2 = (int)(val2);
32044 : {
32045 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32046 0 : if (arg1) (arg1)->level = arg2;
32047 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32048 : }
32049 0 : resultobj = SWIG_Py_Void();
32050 0 : return resultobj;
32051 : fail:
32052 : return NULL;
32053 : }
32054 :
32055 :
32056 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32057 0 : PyObject *resultobj = 0;
32058 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32059 0 : void *argp1 = 0 ;
32060 0 : int res1 = 0 ;
32061 0 : PyObject * obj0 = 0 ;
32062 : int result;
32063 :
32064 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_level_get",&obj0)) SWIG_fail;
32065 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32066 0 : if (!SWIG_IsOK(res1)) {
32067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_level_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32068 : }
32069 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32070 : {
32071 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32072 0 : result = (int) ((arg1)->level);
32073 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32074 : }
32075 0 : resultobj = SWIG_From_int((int)(result));
32076 0 : return resultobj;
32077 : fail:
32078 : return NULL;
32079 : }
32080 :
32081 :
32082 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32083 0 : PyObject *resultobj = 0;
32084 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32085 0 : char *arg2 = (char *) 0 ;
32086 0 : void *argp1 = 0 ;
32087 0 : int res1 = 0 ;
32088 : int res2 ;
32089 0 : char *buf2 = 0 ;
32090 0 : int alloc2 = 0 ;
32091 0 : PyObject * obj0 = 0 ;
32092 0 : PyObject * obj1 = 0 ;
32093 :
32094 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_owner_trust_set",&obj0,&obj1)) SWIG_fail;
32095 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32096 0 : if (!SWIG_IsOK(res1)) {
32097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32098 : }
32099 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32100 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32101 0 : if (!SWIG_IsOK(res2)) {
32102 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_owner_trust_set" "', argument " "2"" of type '" "char *""'");
32103 : }
32104 0 : arg2 = (char *)(buf2);
32105 : {
32106 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32107 0 : if (arg1->owner_trust) free((char*)arg1->owner_trust);
32108 0 : if (arg2) {
32109 0 : size_t size = strlen((const char *)(arg2)) + 1;
32110 0 : arg1->owner_trust = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
32111 : } else {
32112 0 : arg1->owner_trust = 0;
32113 : }
32114 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32115 : }
32116 0 : resultobj = SWIG_Py_Void();
32117 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32118 : return resultobj;
32119 : fail:
32120 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32121 : return NULL;
32122 : }
32123 :
32124 :
32125 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32126 0 : PyObject *resultobj = 0;
32127 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32128 0 : void *argp1 = 0 ;
32129 0 : int res1 = 0 ;
32130 0 : PyObject * obj0 = 0 ;
32131 0 : char *result = 0 ;
32132 :
32133 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_owner_trust_get",&obj0)) SWIG_fail;
32134 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32135 0 : if (!SWIG_IsOK(res1)) {
32136 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32137 : }
32138 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32139 : {
32140 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32141 0 : result = (char *) ((arg1)->owner_trust);
32142 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32143 : }
32144 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32145 0 : return resultobj;
32146 : fail:
32147 : return NULL;
32148 : }
32149 :
32150 :
32151 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32152 0 : PyObject *resultobj = 0;
32153 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32154 : char *arg2 ;
32155 0 : void *argp1 = 0 ;
32156 0 : int res1 = 0 ;
32157 : char temp2[2] ;
32158 : int res2 ;
32159 0 : PyObject * obj0 = 0 ;
32160 0 : PyObject * obj1 = 0 ;
32161 :
32162 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__owner_trust_set",&obj0,&obj1)) SWIG_fail;
32163 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32164 0 : if (!SWIG_IsOK(res1)) {
32165 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32166 : }
32167 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32168 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
32169 0 : if (!SWIG_IsOK(res2)) {
32170 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__owner_trust_set" "', argument " "2"" of type '" "char [2]""'");
32171 : }
32172 0 : arg2 = (char *)(temp2);
32173 : {
32174 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32175 0 : if (arg2) memcpy(arg1->_owner_trust,arg2,2*sizeof(char));
32176 : else memset(arg1->_owner_trust,0,2*sizeof(char));
32177 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32178 : }
32179 0 : resultobj = SWIG_Py_Void();
32180 0 : return resultobj;
32181 : fail:
32182 : return NULL;
32183 : }
32184 :
32185 :
32186 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__owner_trust_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32187 0 : PyObject *resultobj = 0;
32188 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32189 0 : void *argp1 = 0 ;
32190 0 : int res1 = 0 ;
32191 0 : PyObject * obj0 = 0 ;
32192 0 : char *result = 0 ;
32193 :
32194 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__owner_trust_get",&obj0)) SWIG_fail;
32195 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32196 0 : if (!SWIG_IsOK(res1)) {
32197 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__owner_trust_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32198 : }
32199 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32200 : {
32201 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32202 0 : result = (char *)(char *) ((arg1)->_owner_trust);
32203 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32204 : }
32205 : {
32206 0 : size_t size = SWIG_strnlen(result, 2);
32207 :
32208 :
32209 :
32210 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
32211 : }
32212 0 : return resultobj;
32213 : fail:
32214 : return NULL;
32215 : }
32216 :
32217 :
32218 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32219 0 : PyObject *resultobj = 0;
32220 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32221 0 : char *arg2 = (char *) 0 ;
32222 0 : void *argp1 = 0 ;
32223 0 : int res1 = 0 ;
32224 : int res2 ;
32225 0 : char *buf2 = 0 ;
32226 0 : int alloc2 = 0 ;
32227 0 : PyObject * obj0 = 0 ;
32228 0 : PyObject * obj1 = 0 ;
32229 :
32230 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_validity_set",&obj0,&obj1)) SWIG_fail;
32231 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32232 0 : if (!SWIG_IsOK(res1)) {
32233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32234 : }
32235 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32236 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32237 0 : if (!SWIG_IsOK(res2)) {
32238 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_validity_set" "', argument " "2"" of type '" "char *""'");
32239 : }
32240 0 : arg2 = (char *)(buf2);
32241 : {
32242 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32243 0 : if (arg1->validity) free((char*)arg1->validity);
32244 0 : if (arg2) {
32245 0 : size_t size = strlen((const char *)(arg2)) + 1;
32246 0 : arg1->validity = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
32247 : } else {
32248 0 : arg1->validity = 0;
32249 : }
32250 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32251 : }
32252 0 : resultobj = SWIG_Py_Void();
32253 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32254 : return resultobj;
32255 : fail:
32256 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32257 : return NULL;
32258 : }
32259 :
32260 :
32261 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32262 0 : PyObject *resultobj = 0;
32263 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32264 0 : void *argp1 = 0 ;
32265 0 : int res1 = 0 ;
32266 0 : PyObject * obj0 = 0 ;
32267 0 : char *result = 0 ;
32268 :
32269 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_validity_get",&obj0)) SWIG_fail;
32270 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32271 0 : if (!SWIG_IsOK(res1)) {
32272 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32273 : }
32274 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32275 : {
32276 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32277 0 : result = (char *) ((arg1)->validity);
32278 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32279 : }
32280 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32281 0 : return resultobj;
32282 : fail:
32283 : return NULL;
32284 : }
32285 :
32286 :
32287 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32288 0 : PyObject *resultobj = 0;
32289 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32290 : char *arg2 ;
32291 0 : void *argp1 = 0 ;
32292 0 : int res1 = 0 ;
32293 : char temp2[2] ;
32294 : int res2 ;
32295 0 : PyObject * obj0 = 0 ;
32296 0 : PyObject * obj1 = 0 ;
32297 :
32298 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item__validity_set",&obj0,&obj1)) SWIG_fail;
32299 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32300 0 : if (!SWIG_IsOK(res1)) {
32301 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32302 : }
32303 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32304 0 : res2 = SWIG_AsCharArray(obj1, temp2, 2);
32305 0 : if (!SWIG_IsOK(res2)) {
32306 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item__validity_set" "', argument " "2"" of type '" "char [2]""'");
32307 : }
32308 0 : arg2 = (char *)(temp2);
32309 : {
32310 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32311 0 : if (arg2) memcpy(arg1->_validity,arg2,2*sizeof(char));
32312 : else memset(arg1->_validity,0,2*sizeof(char));
32313 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32314 : }
32315 0 : resultobj = SWIG_Py_Void();
32316 0 : return resultobj;
32317 : fail:
32318 : return NULL;
32319 : }
32320 :
32321 :
32322 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item__validity_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32323 0 : PyObject *resultobj = 0;
32324 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32325 0 : void *argp1 = 0 ;
32326 0 : int res1 = 0 ;
32327 0 : PyObject * obj0 = 0 ;
32328 0 : char *result = 0 ;
32329 :
32330 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item__validity_get",&obj0)) SWIG_fail;
32331 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32332 0 : if (!SWIG_IsOK(res1)) {
32333 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item__validity_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32334 : }
32335 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32336 : {
32337 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32338 0 : result = (char *)(char *) ((arg1)->_validity);
32339 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32340 : }
32341 : {
32342 0 : size_t size = SWIG_strnlen(result, 2);
32343 :
32344 :
32345 :
32346 0 : resultobj = SWIG_FromCharPtrAndSize(result, size);
32347 : }
32348 0 : return resultobj;
32349 : fail:
32350 : return NULL;
32351 : }
32352 :
32353 :
32354 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32355 0 : PyObject *resultobj = 0;
32356 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32357 0 : char *arg2 = (char *) 0 ;
32358 0 : void *argp1 = 0 ;
32359 0 : int res1 = 0 ;
32360 : int res2 ;
32361 0 : char *buf2 = 0 ;
32362 0 : int alloc2 = 0 ;
32363 0 : PyObject * obj0 = 0 ;
32364 0 : PyObject * obj1 = 0 ;
32365 :
32366 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_trust_item_name_set",&obj0,&obj1)) SWIG_fail;
32367 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32368 0 : if (!SWIG_IsOK(res1)) {
32369 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_set" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32370 : }
32371 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32372 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
32373 0 : if (!SWIG_IsOK(res2)) {
32374 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_trust_item_name_set" "', argument " "2"" of type '" "char *""'");
32375 : }
32376 0 : arg2 = (char *)(buf2);
32377 : {
32378 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32379 0 : if (arg1->name) free((char*)arg1->name);
32380 0 : if (arg2) {
32381 0 : size_t size = strlen((const char *)(arg2)) + 1;
32382 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
32383 : } else {
32384 0 : arg1->name = 0;
32385 : }
32386 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32387 : }
32388 0 : resultobj = SWIG_Py_Void();
32389 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32390 : return resultobj;
32391 : fail:
32392 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
32393 : return NULL;
32394 : }
32395 :
32396 :
32397 0 : SWIGINTERN PyObject *_wrap__gpgme_trust_item_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32398 0 : PyObject *resultobj = 0;
32399 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32400 0 : void *argp1 = 0 ;
32401 0 : int res1 = 0 ;
32402 0 : PyObject * obj0 = 0 ;
32403 0 : char *result = 0 ;
32404 :
32405 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_trust_item_name_get",&obj0)) SWIG_fail;
32406 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32407 0 : if (!SWIG_IsOK(res1)) {
32408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_trust_item_name_get" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32409 : }
32410 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32411 : {
32412 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32413 0 : result = (char *) ((arg1)->name);
32414 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32415 : }
32416 0 : resultobj = SWIG_FromCharPtr((const char *)result);
32417 0 : return resultobj;
32418 : fail:
32419 : return NULL;
32420 : }
32421 :
32422 :
32423 0 : SWIGINTERN PyObject *_wrap_new__gpgme_trust_item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32424 0 : PyObject *resultobj = 0;
32425 0 : struct _gpgme_trust_item *result = 0 ;
32426 :
32427 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_trust_item")) SWIG_fail;
32428 : {
32429 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32430 0 : result = (struct _gpgme_trust_item *)calloc(1, sizeof(struct _gpgme_trust_item));
32431 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32432 : }
32433 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, SWIG_POINTER_NEW | 0 );
32434 0 : return resultobj;
32435 : fail:
32436 : return NULL;
32437 : }
32438 :
32439 :
32440 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_trust_item(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 0 : PyObject *resultobj = 0;
32442 0 : struct _gpgme_trust_item *arg1 = (struct _gpgme_trust_item *) 0 ;
32443 0 : void *argp1 = 0 ;
32444 0 : int res1 = 0 ;
32445 0 : PyObject * obj0 = 0 ;
32446 :
32447 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_trust_item",&obj0)) SWIG_fail;
32448 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, SWIG_POINTER_DISOWN | 0 );
32449 0 : if (!SWIG_IsOK(res1)) {
32450 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_trust_item" "', argument " "1"" of type '" "struct _gpgme_trust_item *""'");
32451 : }
32452 0 : arg1 = (struct _gpgme_trust_item *)(argp1);
32453 : {
32454 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32455 0 : free((char *) arg1);
32456 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32457 : }
32458 0 : resultobj = SWIG_Py_Void();
32459 0 : return resultobj;
32460 : fail:
32461 : return NULL;
32462 : }
32463 :
32464 :
32465 27 : SWIGINTERN PyObject *_gpgme_trust_item_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32466 : PyObject *obj;
32467 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
32468 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_trust_item, SWIG_NewClientData(obj));
32469 27 : return SWIG_Py_Void();
32470 : }
32471 :
32472 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32473 2 : PyObject *resultobj = 0;
32474 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32475 2 : char *arg2 = (char *) 0 ;
32476 : int arg3 ;
32477 2 : void *argp1 = 0 ;
32478 2 : int res1 = 0 ;
32479 2 : PyObject *encodedInput2 = NULL ;
32480 : int val3 ;
32481 2 : int ecode3 = 0 ;
32482 2 : PyObject * obj0 = 0 ;
32483 2 : PyObject * obj1 = 0 ;
32484 2 : PyObject * obj2 = 0 ;
32485 : gpgme_error_t result;
32486 :
32487 2 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_trustlist_start",&obj0,&obj1,&obj2)) SWIG_fail;
32488 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32489 2 : if (!SWIG_IsOK(res1)) {
32490 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32491 : }
32492 2 : arg1 = (gpgme_ctx_t)(argp1);
32493 : {
32494 2 : if (obj1 == Py_None)
32495 : arg2 = NULL;
32496 2 : else if (PyUnicode_Check(obj1))
32497 : {
32498 2 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
32499 2 : if (encodedInput2 == NULL)
32500 : return NULL;
32501 2 : arg2 = PyBytes_AsString(encodedInput2);
32502 : }
32503 0 : else if (PyBytes_Check(obj1))
32504 0 : arg2 = PyBytes_AsString(obj1);
32505 : else {
32506 0 : PyErr_Format(PyExc_TypeError,
32507 : "arg %d: expected str, bytes, or None, got %s",
32508 : 2, obj1->ob_type->tp_name);
32509 0 : return NULL;
32510 : }
32511 : }
32512 4 : ecode3 = SWIG_AsVal_int(obj2, &val3);
32513 2 : if (!SWIG_IsOK(ecode3)) {
32514 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_trustlist_start" "', argument " "3"" of type '" "int""'");
32515 : }
32516 2 : arg3 = (int)(val3);
32517 : {
32518 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32519 2 : result = gpgme_op_trustlist_start(arg1,(char const *)arg2,arg3);
32520 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32521 : }
32522 : {
32523 2 : resultobj = PyLong_FromLong(result);
32524 : }
32525 : {
32526 2 : Py_XDECREF(encodedInput2);
32527 : }
32528 : return resultobj;
32529 : fail:
32530 : {
32531 0 : Py_XDECREF(encodedInput2);
32532 : }
32533 : return NULL;
32534 : }
32535 :
32536 :
32537 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_next(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32538 2 : PyObject *resultobj = 0;
32539 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32540 2 : gpgme_trust_item_t *arg2 = (gpgme_trust_item_t *) 0 ;
32541 2 : void *argp1 = 0 ;
32542 2 : int res1 = 0 ;
32543 2 : void *argp2 = 0 ;
32544 2 : int res2 = 0 ;
32545 2 : PyObject * obj0 = 0 ;
32546 2 : PyObject * obj1 = 0 ;
32547 : gpgme_error_t result;
32548 :
32549 2 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_trustlist_next",&obj0,&obj1)) SWIG_fail;
32550 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32551 2 : if (!SWIG_IsOK(res1)) {
32552 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_next" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32553 : }
32554 2 : arg1 = (gpgme_ctx_t)(argp1);
32555 2 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
32556 2 : if (!SWIG_IsOK(res2)) {
32557 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_trustlist_next" "', argument " "2"" of type '" "gpgme_trust_item_t *""'");
32558 : }
32559 2 : arg2 = (gpgme_trust_item_t *)(argp2);
32560 : {
32561 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32562 2 : result = gpgme_op_trustlist_next(arg1,arg2);
32563 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32564 : }
32565 : {
32566 2 : resultobj = PyLong_FromLong(result);
32567 : }
32568 2 : return resultobj;
32569 : fail:
32570 : return NULL;
32571 : }
32572 :
32573 :
32574 2 : SWIGINTERN PyObject *_wrap_gpgme_op_trustlist_end(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32575 2 : PyObject *resultobj = 0;
32576 2 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32577 2 : void *argp1 = 0 ;
32578 2 : int res1 = 0 ;
32579 2 : PyObject * obj0 = 0 ;
32580 : gpgme_error_t result;
32581 :
32582 2 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_trustlist_end",&obj0)) SWIG_fail;
32583 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32584 2 : if (!SWIG_IsOK(res1)) {
32585 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_trustlist_end" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32586 : }
32587 2 : arg1 = (gpgme_ctx_t)(argp1);
32588 : {
32589 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32590 2 : result = gpgme_op_trustlist_end(arg1);
32591 2 : SWIG_PYTHON_THREAD_END_ALLOW;
32592 : }
32593 : {
32594 2 : resultobj = PyLong_FromLong(result);
32595 : }
32596 2 : return resultobj;
32597 : fail:
32598 : return NULL;
32599 : }
32600 :
32601 :
32602 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32603 0 : PyObject *resultobj = 0;
32604 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
32605 0 : void *argp1 = 0 ;
32606 0 : int res1 = 0 ;
32607 0 : PyObject * obj0 = 0 ;
32608 :
32609 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_ref",&obj0)) SWIG_fail;
32610 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32611 0 : if (!SWIG_IsOK(res1)) {
32612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_ref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
32613 : }
32614 0 : arg1 = (gpgme_trust_item_t)(argp1);
32615 : {
32616 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32617 0 : gpgme_trust_item_ref(arg1);
32618 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32619 : }
32620 0 : resultobj = SWIG_Py_Void();
32621 0 : return resultobj;
32622 : fail:
32623 : return NULL;
32624 : }
32625 :
32626 :
32627 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32628 0 : PyObject *resultobj = 0;
32629 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
32630 0 : void *argp1 = 0 ;
32631 0 : int res1 = 0 ;
32632 0 : PyObject * obj0 = 0 ;
32633 :
32634 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_unref",&obj0)) SWIG_fail;
32635 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
32636 0 : if (!SWIG_IsOK(res1)) {
32637 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_unref" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
32638 : }
32639 0 : arg1 = (gpgme_trust_item_t)(argp1);
32640 : {
32641 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32642 0 : gpgme_trust_item_unref(arg1);
32643 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32644 : }
32645 0 : resultobj = SWIG_Py_Void();
32646 0 : return resultobj;
32647 : fail:
32648 : return NULL;
32649 : }
32650 :
32651 :
32652 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32653 0 : PyObject *resultobj = 0;
32654 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32655 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
32656 : unsigned int arg3 ;
32657 0 : void *argp1 = 0 ;
32658 0 : int res1 = 0 ;
32659 0 : void *argp2 = 0 ;
32660 0 : int res2 = 0 ;
32661 : unsigned int val3 ;
32662 0 : int ecode3 = 0 ;
32663 0 : PyObject * obj0 = 0 ;
32664 0 : PyObject * obj1 = 0 ;
32665 0 : PyObject * obj2 = 0 ;
32666 : gpgme_error_t result;
32667 :
32668 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog_start",&obj0,&obj1,&obj2)) SWIG_fail;
32669 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32670 0 : if (!SWIG_IsOK(res1)) {
32671 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32672 : }
32673 0 : arg1 = (gpgme_ctx_t)(argp1);
32674 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
32675 0 : if (!SWIG_IsOK(res2)) {
32676 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog_start" "', argument " "2"" of type '" "gpgme_data_t""'");
32677 : }
32678 0 : arg2 = (gpgme_data_t)(argp2);
32679 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
32680 0 : if (!SWIG_IsOK(ecode3)) {
32681 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog_start" "', argument " "3"" of type '" "unsigned int""'");
32682 : }
32683 0 : arg3 = (unsigned int)(val3);
32684 : {
32685 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32686 0 : result = gpgme_op_getauditlog_start(arg1,arg2,arg3);
32687 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32688 : }
32689 : {
32690 0 : resultobj = PyLong_FromLong(result);
32691 : }
32692 0 : return resultobj;
32693 : fail:
32694 : return NULL;
32695 : }
32696 :
32697 :
32698 0 : SWIGINTERN PyObject *_wrap_gpgme_op_getauditlog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32699 0 : PyObject *resultobj = 0;
32700 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32701 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
32702 : unsigned int arg3 ;
32703 0 : void *argp1 = 0 ;
32704 0 : int res1 = 0 ;
32705 0 : void *argp2 = 0 ;
32706 0 : int res2 = 0 ;
32707 : unsigned int val3 ;
32708 0 : int ecode3 = 0 ;
32709 0 : PyObject * obj0 = 0 ;
32710 0 : PyObject * obj1 = 0 ;
32711 0 : PyObject * obj2 = 0 ;
32712 : gpgme_error_t result;
32713 :
32714 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_op_getauditlog",&obj0,&obj1,&obj2)) SWIG_fail;
32715 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32716 0 : if (!SWIG_IsOK(res1)) {
32717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_getauditlog" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32718 : }
32719 0 : arg1 = (gpgme_ctx_t)(argp1);
32720 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
32721 0 : if (!SWIG_IsOK(res2)) {
32722 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_getauditlog" "', argument " "2"" of type '" "gpgme_data_t""'");
32723 : }
32724 0 : arg2 = (gpgme_data_t)(argp2);
32725 0 : ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
32726 0 : if (!SWIG_IsOK(ecode3)) {
32727 0 : SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "gpgme_op_getauditlog" "', argument " "3"" of type '" "unsigned int""'");
32728 : }
32729 0 : arg3 = (unsigned int)(val3);
32730 : {
32731 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32732 0 : result = gpgme_op_getauditlog(arg1,arg2,arg3);
32733 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32734 : }
32735 : {
32736 0 : resultobj = PyLong_FromLong(result);
32737 : }
32738 0 : return resultobj;
32739 : fail:
32740 : return NULL;
32741 : }
32742 :
32743 :
32744 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32745 0 : PyObject *resultobj = 0;
32746 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32747 0 : char *arg2 = (char *) 0 ;
32748 : char **arg3 ;
32749 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
32750 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
32751 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
32752 : unsigned int arg7 ;
32753 0 : void *argp1 = 0 ;
32754 0 : int res1 = 0 ;
32755 0 : PyObject *encodedInput2 = NULL ;
32756 0 : void *vector3 = NULL ;
32757 : size_t size3 ;
32758 0 : PyObject **pyVector3 = NULL ;
32759 0 : void *argp4 = 0 ;
32760 0 : int res4 = 0 ;
32761 0 : void *argp5 = 0 ;
32762 0 : int res5 = 0 ;
32763 0 : void *argp6 = 0 ;
32764 0 : int res6 = 0 ;
32765 : unsigned int val7 ;
32766 0 : int ecode7 = 0 ;
32767 0 : PyObject * obj0 = 0 ;
32768 0 : PyObject * obj1 = 0 ;
32769 0 : PyObject * obj2 = 0 ;
32770 0 : PyObject * obj3 = 0 ;
32771 0 : PyObject * obj4 = 0 ;
32772 0 : PyObject * obj5 = 0 ;
32773 0 : PyObject * obj6 = 0 ;
32774 : gpgme_error_t result;
32775 :
32776 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn_start",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32777 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32778 0 : if (!SWIG_IsOK(res1)) {
32779 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32780 : }
32781 0 : arg1 = (gpgme_ctx_t)(argp1);
32782 : {
32783 0 : if (obj1 == Py_None)
32784 : arg2 = NULL;
32785 0 : else if (PyUnicode_Check(obj1))
32786 : {
32787 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
32788 0 : if (encodedInput2 == NULL)
32789 : return NULL;
32790 0 : arg2 = PyBytes_AsString(encodedInput2);
32791 : }
32792 0 : else if (PyBytes_Check(obj1))
32793 0 : arg2 = PyBytes_AsString(obj1);
32794 : else {
32795 0 : PyErr_Format(PyExc_TypeError,
32796 : "arg %d: expected str, bytes, or None, got %s",
32797 : 2, obj1->ob_type->tp_name);
32798 0 : return NULL;
32799 : }
32800 : }
32801 : {
32802 : /* Check if is a list */
32803 0 : if (PyList_Check(obj2)) {
32804 : size_t i, j;
32805 0 : size3 = PyList_Size(obj2);
32806 0 : arg3 = (char **) (vector3 = malloc((size3+1) * sizeof(char *)));
32807 0 : pyVector3 = calloc(sizeof *pyVector3, size3);
32808 :
32809 0 : for (i = 0; i < size3; i++) {
32810 0 : PyObject *o = PyList_GetItem(obj2,i);
32811 0 : if (PyUnicode_Check(o))
32812 : {
32813 0 : pyVector3[i] = PyUnicode_AsUTF8String(o);
32814 0 : if (pyVector3[i] == NULL)
32815 : {
32816 0 : free(vector3);
32817 0 : for (j = 0; j < i; j++)
32818 0 : Py_XDECREF(pyVector3[j]);
32819 : return NULL;
32820 : }
32821 0 : arg3[i] = PyBytes_AsString(pyVector3[i]);
32822 : }
32823 0 : else if (PyString_Check(o))
32824 0 : arg3[i] = PyString_AsString(o);
32825 : else {
32826 0 : PyErr_Format(PyExc_TypeError,
32827 : "arg %d: list must contain only str or bytes, got %s "
32828 : "at position %d",
32829 : 3, o->ob_type->tp_name, i);
32830 0 : free(arg3);
32831 0 : return NULL;
32832 : }
32833 : }
32834 0 : arg3[i] = NULL;
32835 : } else {
32836 0 : PyErr_Format(PyExc_TypeError,
32837 : "arg %d: expected a list of str or bytes, got %s",
32838 : 3, obj2->ob_type->tp_name);
32839 0 : return NULL;
32840 : }
32841 : }
32842 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
32843 0 : if (!SWIG_IsOK(res4)) {
32844 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn_start" "', argument " "4"" of type '" "gpgme_data_t""'");
32845 : }
32846 0 : arg4 = (gpgme_data_t)(argp4);
32847 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
32848 0 : if (!SWIG_IsOK(res5)) {
32849 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn_start" "', argument " "5"" of type '" "gpgme_data_t""'");
32850 : }
32851 0 : arg5 = (gpgme_data_t)(argp5);
32852 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
32853 0 : if (!SWIG_IsOK(res6)) {
32854 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn_start" "', argument " "6"" of type '" "gpgme_data_t""'");
32855 : }
32856 0 : arg6 = (gpgme_data_t)(argp6);
32857 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
32858 0 : if (!SWIG_IsOK(ecode7)) {
32859 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn_start" "', argument " "7"" of type '" "unsigned int""'");
32860 : }
32861 0 : arg7 = (unsigned int)(val7);
32862 : {
32863 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
32864 0 : result = gpgme_op_spawn_start(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
32865 0 : SWIG_PYTHON_THREAD_END_ALLOW;
32866 : }
32867 : {
32868 0 : resultobj = PyLong_FromLong(result);
32869 : }
32870 : {
32871 0 : Py_XDECREF(encodedInput2);
32872 : }
32873 : {
32874 : size_t i;
32875 0 : free(vector3);
32876 0 : for (i = 0; i < size3; i++)
32877 0 : Py_XDECREF(pyVector3[i]);
32878 : }
32879 : return resultobj;
32880 : fail:
32881 : {
32882 0 : Py_XDECREF(encodedInput2);
32883 : }
32884 : {
32885 : size_t i;
32886 0 : free(vector3);
32887 0 : for (i = 0; i < size3; i++)
32888 0 : Py_XDECREF(pyVector3[i]);
32889 : }
32890 : return NULL;
32891 : }
32892 :
32893 :
32894 0 : SWIGINTERN PyObject *_wrap_gpgme_op_spawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32895 0 : PyObject *resultobj = 0;
32896 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
32897 0 : char *arg2 = (char *) 0 ;
32898 : char **arg3 ;
32899 0 : gpgme_data_t arg4 = (gpgme_data_t) 0 ;
32900 0 : gpgme_data_t arg5 = (gpgme_data_t) 0 ;
32901 0 : gpgme_data_t arg6 = (gpgme_data_t) 0 ;
32902 : unsigned int arg7 ;
32903 0 : void *argp1 = 0 ;
32904 0 : int res1 = 0 ;
32905 0 : PyObject *encodedInput2 = NULL ;
32906 0 : void *vector3 = NULL ;
32907 : size_t size3 ;
32908 0 : PyObject **pyVector3 = NULL ;
32909 0 : void *argp4 = 0 ;
32910 0 : int res4 = 0 ;
32911 0 : void *argp5 = 0 ;
32912 0 : int res5 = 0 ;
32913 0 : void *argp6 = 0 ;
32914 0 : int res6 = 0 ;
32915 : unsigned int val7 ;
32916 0 : int ecode7 = 0 ;
32917 0 : PyObject * obj0 = 0 ;
32918 0 : PyObject * obj1 = 0 ;
32919 0 : PyObject * obj2 = 0 ;
32920 0 : PyObject * obj3 = 0 ;
32921 0 : PyObject * obj4 = 0 ;
32922 0 : PyObject * obj5 = 0 ;
32923 0 : PyObject * obj6 = 0 ;
32924 : gpgme_error_t result;
32925 :
32926 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOOOO:gpgme_op_spawn",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32927 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
32928 0 : if (!SWIG_IsOK(res1)) {
32929 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_spawn" "', argument " "1"" of type '" "gpgme_ctx_t""'");
32930 : }
32931 0 : arg1 = (gpgme_ctx_t)(argp1);
32932 : {
32933 0 : if (obj1 == Py_None)
32934 : arg2 = NULL;
32935 0 : else if (PyUnicode_Check(obj1))
32936 : {
32937 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
32938 0 : if (encodedInput2 == NULL)
32939 : return NULL;
32940 0 : arg2 = PyBytes_AsString(encodedInput2);
32941 : }
32942 0 : else if (PyBytes_Check(obj1))
32943 0 : arg2 = PyBytes_AsString(obj1);
32944 : else {
32945 0 : PyErr_Format(PyExc_TypeError,
32946 : "arg %d: expected str, bytes, or None, got %s",
32947 : 2, obj1->ob_type->tp_name);
32948 0 : return NULL;
32949 : }
32950 : }
32951 : {
32952 : /* Check if is a list */
32953 0 : if (PyList_Check(obj2)) {
32954 : size_t i, j;
32955 0 : size3 = PyList_Size(obj2);
32956 0 : arg3 = (char **) (vector3 = malloc((size3+1) * sizeof(char *)));
32957 0 : pyVector3 = calloc(sizeof *pyVector3, size3);
32958 :
32959 0 : for (i = 0; i < size3; i++) {
32960 0 : PyObject *o = PyList_GetItem(obj2,i);
32961 0 : if (PyUnicode_Check(o))
32962 : {
32963 0 : pyVector3[i] = PyUnicode_AsUTF8String(o);
32964 0 : if (pyVector3[i] == NULL)
32965 : {
32966 0 : free(vector3);
32967 0 : for (j = 0; j < i; j++)
32968 0 : Py_XDECREF(pyVector3[j]);
32969 : return NULL;
32970 : }
32971 0 : arg3[i] = PyBytes_AsString(pyVector3[i]);
32972 : }
32973 0 : else if (PyString_Check(o))
32974 0 : arg3[i] = PyString_AsString(o);
32975 : else {
32976 0 : PyErr_Format(PyExc_TypeError,
32977 : "arg %d: list must contain only str or bytes, got %s "
32978 : "at position %d",
32979 : 3, o->ob_type->tp_name, i);
32980 0 : free(arg3);
32981 0 : return NULL;
32982 : }
32983 : }
32984 0 : arg3[i] = NULL;
32985 : } else {
32986 0 : PyErr_Format(PyExc_TypeError,
32987 : "arg %d: expected a list of str or bytes, got %s",
32988 : 3, obj2->ob_type->tp_name);
32989 0 : return NULL;
32990 : }
32991 : }
32992 0 : res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_gpgme_data, 0 | 0 );
32993 0 : if (!SWIG_IsOK(res4)) {
32994 0 : SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "gpgme_op_spawn" "', argument " "4"" of type '" "gpgme_data_t""'");
32995 : }
32996 0 : arg4 = (gpgme_data_t)(argp4);
32997 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpgme_data, 0 | 0 );
32998 0 : if (!SWIG_IsOK(res5)) {
32999 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_spawn" "', argument " "5"" of type '" "gpgme_data_t""'");
33000 : }
33001 0 : arg5 = (gpgme_data_t)(argp5);
33002 0 : res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_gpgme_data, 0 | 0 );
33003 0 : if (!SWIG_IsOK(res6)) {
33004 0 : SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "gpgme_op_spawn" "', argument " "6"" of type '" "gpgme_data_t""'");
33005 : }
33006 0 : arg6 = (gpgme_data_t)(argp6);
33007 0 : ecode7 = SWIG_AsVal_unsigned_SS_int(obj6, &val7);
33008 0 : if (!SWIG_IsOK(ecode7)) {
33009 0 : SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "gpgme_op_spawn" "', argument " "7"" of type '" "unsigned int""'");
33010 : }
33011 0 : arg7 = (unsigned int)(val7);
33012 : {
33013 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33014 0 : result = gpgme_op_spawn(arg1,(char const *)arg2,(char const *(*))arg3,arg4,arg5,arg6,arg7);
33015 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33016 : }
33017 : {
33018 0 : resultobj = PyLong_FromLong(result);
33019 : }
33020 : {
33021 0 : Py_XDECREF(encodedInput2);
33022 : }
33023 : {
33024 : size_t i;
33025 0 : free(vector3);
33026 0 : for (i = 0; i < size3; i++)
33027 0 : Py_XDECREF(pyVector3[i]);
33028 : }
33029 : return resultobj;
33030 : fail:
33031 : {
33032 0 : Py_XDECREF(encodedInput2);
33033 : }
33034 : {
33035 : size_t i;
33036 0 : free(vector3);
33037 0 : for (i = 0; i < size3; i++)
33038 0 : Py_XDECREF(pyVector3[i]);
33039 : }
33040 : return NULL;
33041 : }
33042 :
33043 :
33044 0 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_start(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33045 0 : PyObject *resultobj = 0;
33046 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33047 0 : char *arg2 = (char *) 0 ;
33048 0 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
33049 0 : void *arg4 = (void *) 0 ;
33050 0 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
33051 0 : void *arg6 = (void *) 0 ;
33052 0 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
33053 0 : void *arg8 = (void *) 0 ;
33054 0 : void *argp1 = 0 ;
33055 0 : int res1 = 0 ;
33056 0 : PyObject *encodedInput2 = NULL ;
33057 0 : PyObject * obj0 = 0 ;
33058 0 : PyObject * obj1 = 0 ;
33059 0 : PyObject * obj2 = 0 ;
33060 0 : PyObject * obj3 = 0 ;
33061 0 : PyObject * obj4 = 0 ;
33062 : gpgme_error_t result;
33063 :
33064 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_assuan_transact_start",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33065 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33066 0 : if (!SWIG_IsOK(res1)) {
33067 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_start" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33068 : }
33069 0 : arg1 = (gpgme_ctx_t)(argp1);
33070 : {
33071 0 : if (obj1 == Py_None)
33072 : arg2 = NULL;
33073 0 : else if (PyUnicode_Check(obj1))
33074 : {
33075 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33076 0 : if (encodedInput2 == NULL)
33077 : return NULL;
33078 0 : arg2 = PyBytes_AsString(encodedInput2);
33079 : }
33080 0 : else if (PyBytes_Check(obj1))
33081 0 : arg2 = PyBytes_AsString(obj1);
33082 : else {
33083 0 : PyErr_Format(PyExc_TypeError,
33084 : "arg %d: expected str, bytes, or None, got %s",
33085 : 2, obj1->ob_type->tp_name);
33086 0 : return NULL;
33087 : }
33088 : }
33089 : {
33090 0 : if (obj2 == Py_None)
33091 : arg3 = arg4 = NULL;
33092 : else
33093 : {
33094 0 : if (! PyTuple_Check(obj2))
33095 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33096 0 : if (PyTuple_Size(obj2) != 2)
33097 0 : return PyErr_Format(PyExc_TypeError,
33098 : "callback must be a tuple of size 2");
33099 0 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
33100 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33101 0 : arg3 = _gpg_assuan_data_cb;
33102 0 : arg4 = obj2;
33103 : }
33104 : }
33105 : {
33106 0 : if (obj3 == Py_None)
33107 : arg5 = arg6 = NULL;
33108 : else
33109 : {
33110 0 : if (! PyTuple_Check(obj3))
33111 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33112 0 : if (PyTuple_Size(obj3) != 2)
33113 0 : return PyErr_Format(PyExc_TypeError,
33114 : "callback must be a tuple of size 2");
33115 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
33116 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33117 0 : arg5 = _gpg_assuan_inquire_cb;
33118 0 : arg6 = obj3;
33119 : }
33120 : }
33121 : {
33122 0 : if (obj4 == Py_None)
33123 : arg7 = arg8 = NULL;
33124 : else
33125 : {
33126 0 : if (! PyTuple_Check(obj4))
33127 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33128 0 : if (PyTuple_Size(obj4) != 2)
33129 0 : return PyErr_Format(PyExc_TypeError,
33130 : "callback must be a tuple of size 2");
33131 0 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
33132 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33133 0 : arg7 = _gpg_assuan_status_cb;
33134 0 : arg8 = obj4;
33135 : }
33136 : }
33137 : {
33138 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33139 0 : result = gpgme_op_assuan_transact_start(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
33140 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33141 : }
33142 : {
33143 0 : resultobj = PyLong_FromLong(result);
33144 : }
33145 : {
33146 0 : Py_XDECREF(encodedInput2);
33147 : }
33148 : return resultobj;
33149 : fail:
33150 : {
33151 : Py_XDECREF(encodedInput2);
33152 : }
33153 : return NULL;
33154 : }
33155 :
33156 :
33157 13 : SWIGINTERN PyObject *_wrap_gpgme_op_assuan_transact_ext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33158 13 : PyObject *resultobj = 0;
33159 13 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33160 13 : char *arg2 = (char *) 0 ;
33161 13 : gpgme_assuan_data_cb_t arg3 = (gpgme_assuan_data_cb_t) 0 ;
33162 13 : void *arg4 = (void *) 0 ;
33163 13 : gpgme_assuan_inquire_cb_t arg5 = (gpgme_assuan_inquire_cb_t) 0 ;
33164 13 : void *arg6 = (void *) 0 ;
33165 13 : gpgme_assuan_status_cb_t arg7 = (gpgme_assuan_status_cb_t) 0 ;
33166 13 : void *arg8 = (void *) 0 ;
33167 13 : gpgme_error_t *arg9 = (gpgme_error_t *) 0 ;
33168 13 : void *argp1 = 0 ;
33169 13 : int res1 = 0 ;
33170 13 : PyObject *encodedInput2 = NULL ;
33171 13 : void *argp9 = 0 ;
33172 13 : int res9 = 0 ;
33173 13 : PyObject * obj0 = 0 ;
33174 13 : PyObject * obj1 = 0 ;
33175 13 : PyObject * obj2 = 0 ;
33176 13 : PyObject * obj3 = 0 ;
33177 13 : PyObject * obj4 = 0 ;
33178 13 : PyObject * obj5 = 0 ;
33179 : gpgme_error_t result;
33180 :
33181 13 : if (!PyArg_ParseTuple(args,(char *)"OOOOOO:gpgme_op_assuan_transact_ext",&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33182 13 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33183 13 : if (!SWIG_IsOK(res1)) {
33184 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33185 : }
33186 13 : arg1 = (gpgme_ctx_t)(argp1);
33187 : {
33188 13 : if (obj1 == Py_None)
33189 : arg2 = NULL;
33190 13 : else if (PyUnicode_Check(obj1))
33191 : {
33192 12 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33193 12 : if (encodedInput2 == NULL)
33194 : return NULL;
33195 12 : arg2 = PyBytes_AsString(encodedInput2);
33196 : }
33197 1 : else if (PyBytes_Check(obj1))
33198 1 : arg2 = PyBytes_AsString(obj1);
33199 : else {
33200 0 : PyErr_Format(PyExc_TypeError,
33201 : "arg %d: expected str, bytes, or None, got %s",
33202 : 2, obj1->ob_type->tp_name);
33203 0 : return NULL;
33204 : }
33205 : }
33206 : {
33207 13 : if (obj2 == Py_None)
33208 : arg3 = arg4 = NULL;
33209 : else
33210 : {
33211 2 : if (! PyTuple_Check(obj2))
33212 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33213 2 : if (PyTuple_Size(obj2) != 2)
33214 0 : return PyErr_Format(PyExc_TypeError,
33215 : "callback must be a tuple of size 2");
33216 2 : if (! PyCallable_Check(PyTuple_GetItem(obj2, 1)))
33217 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33218 2 : arg3 = _gpg_assuan_data_cb;
33219 2 : arg4 = obj2;
33220 : }
33221 : }
33222 : {
33223 13 : if (obj3 == Py_None)
33224 : arg5 = arg6 = NULL;
33225 : else
33226 : {
33227 0 : if (! PyTuple_Check(obj3))
33228 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33229 0 : if (PyTuple_Size(obj3) != 2)
33230 0 : return PyErr_Format(PyExc_TypeError,
33231 : "callback must be a tuple of size 2");
33232 0 : if (! PyCallable_Check(PyTuple_GetItem(obj3, 1)))
33233 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33234 0 : arg5 = _gpg_assuan_inquire_cb;
33235 0 : arg6 = obj3;
33236 : }
33237 : }
33238 : {
33239 13 : if (obj4 == Py_None)
33240 : arg7 = arg8 = NULL;
33241 : else
33242 : {
33243 1 : if (! PyTuple_Check(obj4))
33244 0 : return PyErr_Format(PyExc_TypeError, "callback must be a tuple");
33245 1 : if (PyTuple_Size(obj4) != 2)
33246 0 : return PyErr_Format(PyExc_TypeError,
33247 : "callback must be a tuple of size 2");
33248 1 : if (! PyCallable_Check(PyTuple_GetItem(obj4, 1)))
33249 0 : return PyErr_Format(PyExc_TypeError, "second item must be callable");
33250 1 : arg7 = _gpg_assuan_status_cb;
33251 1 : arg8 = obj4;
33252 : }
33253 : }
33254 13 : res9 = SWIG_ConvertPtr(obj5, &argp9,SWIGTYPE_p_gpg_error_t, 0 | 0 );
33255 13 : if (!SWIG_IsOK(res9)) {
33256 0 : SWIG_exception_fail(SWIG_ArgError(res9), "in method '" "gpgme_op_assuan_transact_ext" "', argument " "9"" of type '" "gpgme_error_t *""'");
33257 : }
33258 13 : arg9 = (gpgme_error_t *)(argp9);
33259 : {
33260 13 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33261 13 : result = gpgme_op_assuan_transact_ext(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
33262 13 : SWIG_PYTHON_THREAD_END_ALLOW;
33263 : }
33264 : {
33265 13 : resultobj = PyLong_FromLong(result);
33266 : }
33267 : {
33268 13 : Py_XDECREF(encodedInput2);
33269 : }
33270 : return resultobj;
33271 : fail:
33272 : {
33273 0 : Py_XDECREF(encodedInput2);
33274 : }
33275 : return NULL;
33276 : }
33277 :
33278 :
33279 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33280 0 : PyObject *resultobj = 0;
33281 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
33282 0 : char *arg2 = (char *) 0 ;
33283 0 : void *argp1 = 0 ;
33284 0 : int res1 = 0 ;
33285 : int res2 ;
33286 0 : char *buf2 = 0 ;
33287 0 : int alloc2 = 0 ;
33288 0 : PyObject * obj0 = 0 ;
33289 0 : PyObject * obj1 = 0 ;
33290 :
33291 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_vfs_mount_result_mount_dir_set",&obj0,&obj1)) SWIG_fail;
33292 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
33293 0 : if (!SWIG_IsOK(res1)) {
33294 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_set" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
33295 : }
33296 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
33297 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33298 0 : if (!SWIG_IsOK(res2)) {
33299 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_set" "', argument " "2"" of type '" "char *""'");
33300 : }
33301 0 : arg2 = (char *)(buf2);
33302 : {
33303 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33304 0 : if (arg1->mount_dir) free((char*)arg1->mount_dir);
33305 0 : if (arg2) {
33306 0 : size_t size = strlen((const char *)(arg2)) + 1;
33307 0 : arg1->mount_dir = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
33308 : } else {
33309 0 : arg1->mount_dir = 0;
33310 : }
33311 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33312 : }
33313 0 : resultobj = SWIG_Py_Void();
33314 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33315 : return resultobj;
33316 : fail:
33317 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33318 : return NULL;
33319 : }
33320 :
33321 :
33322 0 : SWIGINTERN PyObject *_wrap__gpgme_op_vfs_mount_result_mount_dir_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33323 0 : PyObject *resultobj = 0;
33324 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
33325 0 : void *argp1 = 0 ;
33326 0 : int res1 = 0 ;
33327 0 : PyObject * obj0 = 0 ;
33328 0 : char *result = 0 ;
33329 :
33330 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_vfs_mount_result_mount_dir_get",&obj0)) SWIG_fail;
33331 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, 0 | 0 );
33332 0 : if (!SWIG_IsOK(res1)) {
33333 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_vfs_mount_result_mount_dir_get" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
33334 : }
33335 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
33336 : {
33337 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33338 0 : result = (char *) ((arg1)->mount_dir);
33339 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33340 : }
33341 0 : resultobj = SWIG_FromCharPtr((const char *)result);
33342 0 : return resultobj;
33343 : fail:
33344 : return NULL;
33345 : }
33346 :
33347 :
33348 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33349 0 : PyObject *resultobj = 0;
33350 0 : struct _gpgme_op_vfs_mount_result *result = 0 ;
33351 :
33352 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_vfs_mount_result")) SWIG_fail;
33353 : {
33354 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33355 0 : result = (struct _gpgme_op_vfs_mount_result *)calloc(1, sizeof(struct _gpgme_op_vfs_mount_result));
33356 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33357 : }
33358 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_POINTER_NEW | 0 );
33359 0 : return resultobj;
33360 : fail:
33361 : return NULL;
33362 : }
33363 :
33364 :
33365 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33366 0 : PyObject *resultobj = 0;
33367 0 : struct _gpgme_op_vfs_mount_result *arg1 = (struct _gpgme_op_vfs_mount_result *) 0 ;
33368 0 : void *argp1 = 0 ;
33369 0 : int res1 = 0 ;
33370 0 : PyObject * obj0 = 0 ;
33371 :
33372 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_vfs_mount_result",&obj0)) SWIG_fail;
33373 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_POINTER_DISOWN | 0 );
33374 0 : if (!SWIG_IsOK(res1)) {
33375 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_vfs_mount_result" "', argument " "1"" of type '" "struct _gpgme_op_vfs_mount_result *""'");
33376 : }
33377 0 : arg1 = (struct _gpgme_op_vfs_mount_result *)(argp1);
33378 : {
33379 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33380 0 : free((char *) arg1);
33381 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33382 : }
33383 0 : resultobj = SWIG_Py_Void();
33384 0 : return resultobj;
33385 : fail:
33386 : return NULL;
33387 : }
33388 :
33389 :
33390 27 : SWIGINTERN PyObject *_gpgme_op_vfs_mount_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33391 : PyObject *obj;
33392 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
33393 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_vfs_mount_result, SWIG_NewClientData(obj));
33394 27 : return SWIG_Py_Void();
33395 : }
33396 :
33397 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33398 0 : PyObject *resultobj = 0;
33399 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33400 0 : void *argp1 = 0 ;
33401 0 : int res1 = 0 ;
33402 0 : PyObject * obj0 = 0 ;
33403 : gpgme_vfs_mount_result_t result;
33404 :
33405 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_vfs_mount_result",&obj0)) SWIG_fail;
33406 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33407 0 : if (!SWIG_IsOK(res1)) {
33408 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33409 : }
33410 0 : arg1 = (gpgme_ctx_t)(argp1);
33411 : {
33412 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33413 0 : result = (gpgme_vfs_mount_result_t)gpgme_op_vfs_mount_result(arg1);
33414 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33415 : }
33416 : {
33417 : PyObject *fragile;
33418 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_vfs_mount_result,
33419 : 0 );
33420 0 : resultobj = _gpg_wrap_result(fragile, "VFSMountResult");
33421 0 : Py_DECREF(fragile);
33422 : }
33423 : return resultobj;
33424 : fail:
33425 : return NULL;
33426 : }
33427 :
33428 :
33429 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_mount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33430 0 : PyObject *resultobj = 0;
33431 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33432 0 : char *arg2 = (char *) 0 ;
33433 0 : char *arg3 = (char *) 0 ;
33434 : unsigned int arg4 ;
33435 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
33436 0 : void *argp1 = 0 ;
33437 0 : int res1 = 0 ;
33438 0 : PyObject *encodedInput2 = NULL ;
33439 0 : PyObject *encodedInput3 = NULL ;
33440 : unsigned int val4 ;
33441 0 : int ecode4 = 0 ;
33442 0 : void *argp5 = 0 ;
33443 0 : int res5 = 0 ;
33444 0 : PyObject * obj0 = 0 ;
33445 0 : PyObject * obj1 = 0 ;
33446 0 : PyObject * obj2 = 0 ;
33447 0 : PyObject * obj3 = 0 ;
33448 0 : PyObject * obj4 = 0 ;
33449 : gpgme_error_t result;
33450 :
33451 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_mount",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33452 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33453 0 : if (!SWIG_IsOK(res1)) {
33454 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_mount" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33455 : }
33456 0 : arg1 = (gpgme_ctx_t)(argp1);
33457 : {
33458 0 : if (obj1 == Py_None)
33459 : arg2 = NULL;
33460 0 : else if (PyUnicode_Check(obj1))
33461 : {
33462 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
33463 0 : if (encodedInput2 == NULL)
33464 : return NULL;
33465 0 : arg2 = PyBytes_AsString(encodedInput2);
33466 : }
33467 0 : else if (PyBytes_Check(obj1))
33468 0 : arg2 = PyBytes_AsString(obj1);
33469 : else {
33470 0 : PyErr_Format(PyExc_TypeError,
33471 : "arg %d: expected str, bytes, or None, got %s",
33472 : 2, obj1->ob_type->tp_name);
33473 0 : return NULL;
33474 : }
33475 : }
33476 : {
33477 0 : if (obj2 == Py_None)
33478 : arg3 = NULL;
33479 0 : else if (PyUnicode_Check(obj2))
33480 : {
33481 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
33482 0 : if (encodedInput3 == NULL)
33483 : return NULL;
33484 0 : arg3 = PyBytes_AsString(encodedInput3);
33485 : }
33486 0 : else if (PyBytes_Check(obj2))
33487 0 : arg3 = PyBytes_AsString(obj2);
33488 : else {
33489 0 : PyErr_Format(PyExc_TypeError,
33490 : "arg %d: expected str, bytes, or None, got %s",
33491 : 3, obj2->ob_type->tp_name);
33492 0 : return NULL;
33493 : }
33494 : }
33495 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
33496 0 : if (!SWIG_IsOK(ecode4)) {
33497 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_mount" "', argument " "4"" of type '" "unsigned int""'");
33498 : }
33499 0 : arg4 = (unsigned int)(val4);
33500 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
33501 0 : if (!SWIG_IsOK(res5)) {
33502 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_mount" "', argument " "5"" of type '" "gpgme_error_t *""'");
33503 : }
33504 0 : arg5 = (gpgme_error_t *)(argp5);
33505 : {
33506 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33507 0 : result = gpgme_op_vfs_mount(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
33508 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33509 : }
33510 : {
33511 0 : resultobj = PyLong_FromLong(result);
33512 : }
33513 : {
33514 0 : Py_XDECREF(encodedInput2);
33515 : }
33516 : {
33517 0 : Py_XDECREF(encodedInput3);
33518 : }
33519 : return resultobj;
33520 : fail:
33521 : {
33522 0 : Py_XDECREF(encodedInput2);
33523 : }
33524 : {
33525 0 : Py_XDECREF(encodedInput3);
33526 : }
33527 : return NULL;
33528 : }
33529 :
33530 :
33531 0 : SWIGINTERN PyObject *_wrap_gpgme_op_vfs_create(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33532 0 : PyObject *resultobj = 0;
33533 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
33534 : gpgme_key_t *arg2 ;
33535 0 : char *arg3 = (char *) 0 ;
33536 : unsigned int arg4 ;
33537 0 : gpgme_error_t *arg5 = (gpgme_error_t *) 0 ;
33538 0 : void *argp1 = 0 ;
33539 0 : int res1 = 0 ;
33540 0 : PyObject *encodedInput3 = NULL ;
33541 : unsigned int val4 ;
33542 0 : int ecode4 = 0 ;
33543 0 : void *argp5 = 0 ;
33544 0 : int res5 = 0 ;
33545 0 : PyObject * obj0 = 0 ;
33546 0 : PyObject * obj1 = 0 ;
33547 0 : PyObject * obj2 = 0 ;
33548 0 : PyObject * obj3 = 0 ;
33549 0 : PyObject * obj4 = 0 ;
33550 : gpgme_error_t result;
33551 :
33552 : {
33553 0 : arg2 = NULL;
33554 : }
33555 0 : if (!PyArg_ParseTuple(args,(char *)"OOOOO:gpgme_op_vfs_create",&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
33556 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
33557 0 : if (!SWIG_IsOK(res1)) {
33558 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_vfs_create" "', argument " "1"" of type '" "gpgme_ctx_t""'");
33559 : }
33560 0 : arg1 = (gpgme_ctx_t)(argp1);
33561 : {
33562 0 : int i, numb = 0;
33563 0 : if (!PySequence_Check(obj1)) {
33564 0 : PyErr_Format(PyExc_ValueError, "arg %d: Expected a list of gpgme_key_t",
33565 : 2);
33566 0 : return NULL;
33567 : }
33568 0 : if((numb = PySequence_Length(obj1)) != 0) {
33569 0 : arg2 = (gpgme_key_t*)malloc((numb+1)*sizeof(gpgme_key_t));
33570 0 : for(i=0; i<numb; i++) {
33571 0 : PyObject *pypointer = PySequence_GetItem(obj1, i);
33572 :
33573 : /* input = obj1, 1 = arg2, 1_descriptor = SWIGTYPE_p_p__gpgme_key */
33574 : /* &1_descriptor = SWIGTYPE_p_a___p__gpgme_key *1_descriptor = SWIGTYPE_p__gpgme_key */
33575 :
33576 : /* Following code is from swig's python.swg. */
33577 0 : if ((SWIG_ConvertPtr(pypointer,(void **) &arg2[i], SWIGTYPE_p__gpgme_key,SWIG_POINTER_EXCEPTION | 0 )) == -1) {
33578 0 : Py_DECREF(pypointer);
33579 0 : PyErr_Format(PyExc_TypeError,
33580 : "arg %d: list must contain only gpgme_key_ts, got %s "
33581 : "at position %d",
33582 0 : 2, pypointer->ob_type->tp_name, i);
33583 0 : free(arg2);
33584 0 : return NULL;
33585 : }
33586 0 : Py_DECREF(pypointer);
33587 : }
33588 0 : arg2[numb] = NULL;
33589 : }
33590 : }
33591 : {
33592 0 : if (obj2 == Py_None)
33593 : arg3 = NULL;
33594 0 : else if (PyUnicode_Check(obj2))
33595 : {
33596 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
33597 0 : if (encodedInput3 == NULL)
33598 : return NULL;
33599 0 : arg3 = PyBytes_AsString(encodedInput3);
33600 : }
33601 0 : else if (PyBytes_Check(obj2))
33602 0 : arg3 = PyBytes_AsString(obj2);
33603 : else {
33604 0 : PyErr_Format(PyExc_TypeError,
33605 : "arg %d: expected str, bytes, or None, got %s",
33606 : 3, obj2->ob_type->tp_name);
33607 0 : return NULL;
33608 : }
33609 : }
33610 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
33611 0 : if (!SWIG_IsOK(ecode4)) {
33612 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_vfs_create" "', argument " "4"" of type '" "unsigned int""'");
33613 : }
33614 0 : arg4 = (unsigned int)(val4);
33615 0 : res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_gpg_error_t, 0 | 0 );
33616 0 : if (!SWIG_IsOK(res5)) {
33617 0 : SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "gpgme_op_vfs_create" "', argument " "5"" of type '" "gpgme_error_t *""'");
33618 : }
33619 0 : arg5 = (gpgme_error_t *)(argp5);
33620 : {
33621 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33622 0 : result = gpgme_op_vfs_create(arg1,arg2,(char const *)arg3,arg4,arg5);
33623 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33624 : }
33625 : {
33626 0 : resultobj = PyLong_FromLong(result);
33627 : }
33628 : {
33629 0 : if (arg2) free(arg2);
33630 : }
33631 : {
33632 0 : Py_XDECREF(encodedInput3);
33633 : }
33634 : return resultobj;
33635 : fail:
33636 : {
33637 0 : if (arg2) free(arg2);
33638 : }
33639 : {
33640 0 : Py_XDECREF(encodedInput3);
33641 : }
33642 : return NULL;
33643 : }
33644 :
33645 :
33646 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33647 0 : PyObject *resultobj = 0;
33648 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
33649 : unsigned int arg2 ;
33650 0 : void *argp1 = 0 ;
33651 0 : int res1 = 0 ;
33652 : unsigned int val2 ;
33653 0 : int ecode2 = 0 ;
33654 0 : PyObject * obj0 = 0 ;
33655 0 : PyObject * obj1 = 0 ;
33656 :
33657 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_no_arg_set",&obj0,&obj1)) SWIG_fail;
33658 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
33659 0 : if (!SWIG_IsOK(res1)) {
33660 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
33661 : }
33662 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
33663 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
33664 0 : if (!SWIG_IsOK(ecode2)) {
33665 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_no_arg_set" "', argument " "2"" of type '" "unsigned int""'");
33666 : }
33667 0 : arg2 = (unsigned int)(val2);
33668 : {
33669 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33670 0 : if (arg1) (arg1)->no_arg = arg2;
33671 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33672 : }
33673 0 : resultobj = SWIG_Py_Void();
33674 0 : return resultobj;
33675 : fail:
33676 : return NULL;
33677 : }
33678 :
33679 :
33680 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_no_arg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33681 0 : PyObject *resultobj = 0;
33682 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
33683 0 : void *argp1 = 0 ;
33684 0 : int res1 = 0 ;
33685 0 : PyObject * obj0 = 0 ;
33686 : unsigned int result;
33687 :
33688 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_no_arg_get",&obj0)) SWIG_fail;
33689 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
33690 0 : if (!SWIG_IsOK(res1)) {
33691 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_no_arg_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
33692 : }
33693 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
33694 : {
33695 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33696 0 : result = (unsigned int) ((arg1)->no_arg);
33697 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33698 : }
33699 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
33700 0 : return resultobj;
33701 : fail:
33702 : return NULL;
33703 : }
33704 :
33705 :
33706 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33707 0 : PyObject *resultobj = 0;
33708 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
33709 0 : void *argp1 = 0 ;
33710 0 : int res1 = 0 ;
33711 0 : PyObject * obj0 = 0 ;
33712 0 : gpgme_conf_arg_value *result = 0 ;
33713 :
33714 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_get",&obj0)) SWIG_fail;
33715 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
33716 0 : if (!SWIG_IsOK(res1)) {
33717 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
33718 : }
33719 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
33720 : {
33721 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33722 0 : result = (gpgme_conf_arg_value *)& ((arg1)->value);
33723 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33724 : }
33725 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33726 0 : return resultobj;
33727 : fail:
33728 : return NULL;
33729 : }
33730 :
33731 :
33732 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33733 0 : PyObject *resultobj = 0;
33734 0 : struct gpgme_conf_arg *result = 0 ;
33735 :
33736 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_arg")) SWIG_fail;
33737 : {
33738 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33739 0 : result = (struct gpgme_conf_arg *)calloc(1, sizeof(struct gpgme_conf_arg));
33740 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33741 : }
33742 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_NEW | 0 );
33743 0 : return resultobj;
33744 : fail:
33745 : return NULL;
33746 : }
33747 :
33748 :
33749 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33750 0 : PyObject *resultobj = 0;
33751 0 : struct gpgme_conf_arg *arg1 = (struct gpgme_conf_arg *) 0 ;
33752 0 : void *argp1 = 0 ;
33753 0 : int res1 = 0 ;
33754 0 : PyObject * obj0 = 0 ;
33755 :
33756 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_arg",&obj0)) SWIG_fail;
33757 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
33758 0 : if (!SWIG_IsOK(res1)) {
33759 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg" "', argument " "1"" of type '" "struct gpgme_conf_arg *""'");
33760 : }
33761 0 : arg1 = (struct gpgme_conf_arg *)(argp1);
33762 : {
33763 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33764 0 : free((char *) arg1);
33765 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33766 : }
33767 0 : resultobj = SWIG_Py_Void();
33768 0 : return resultobj;
33769 : fail:
33770 : return NULL;
33771 : }
33772 :
33773 :
33774 27 : SWIGINTERN PyObject *gpgme_conf_arg_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33775 : PyObject *obj;
33776 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
33777 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_arg, SWIG_NewClientData(obj));
33778 27 : return SWIG_Py_Void();
33779 : }
33780 :
33781 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33782 0 : PyObject *resultobj = 0;
33783 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33784 : unsigned int arg2 ;
33785 0 : void *argp1 = 0 ;
33786 0 : int res1 = 0 ;
33787 : unsigned int val2 ;
33788 0 : int ecode2 = 0 ;
33789 0 : PyObject * obj0 = 0 ;
33790 0 : PyObject * obj1 = 0 ;
33791 :
33792 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_count_set",&obj0,&obj1)) SWIG_fail;
33793 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33794 0 : if (!SWIG_IsOK(res1)) {
33795 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33796 : }
33797 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33798 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
33799 0 : if (!SWIG_IsOK(ecode2)) {
33800 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_count_set" "', argument " "2"" of type '" "unsigned int""'");
33801 : }
33802 0 : arg2 = (unsigned int)(val2);
33803 : {
33804 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33805 0 : if (arg1) (arg1)->count = arg2;
33806 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33807 : }
33808 0 : resultobj = SWIG_Py_Void();
33809 0 : return resultobj;
33810 : fail:
33811 : return NULL;
33812 : }
33813 :
33814 :
33815 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_count_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33816 0 : PyObject *resultobj = 0;
33817 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33818 0 : void *argp1 = 0 ;
33819 0 : int res1 = 0 ;
33820 0 : PyObject * obj0 = 0 ;
33821 : unsigned int result;
33822 :
33823 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_count_get",&obj0)) SWIG_fail;
33824 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33825 0 : if (!SWIG_IsOK(res1)) {
33826 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_count_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33827 : }
33828 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33829 : {
33830 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33831 0 : result = (unsigned int) ((arg1)->count);
33832 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33833 : }
33834 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
33835 0 : return resultobj;
33836 : fail:
33837 : return NULL;
33838 : }
33839 :
33840 :
33841 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33842 0 : PyObject *resultobj = 0;
33843 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33844 : unsigned int arg2 ;
33845 0 : void *argp1 = 0 ;
33846 0 : int res1 = 0 ;
33847 : unsigned int val2 ;
33848 0 : int ecode2 = 0 ;
33849 0 : PyObject * obj0 = 0 ;
33850 0 : PyObject * obj1 = 0 ;
33851 :
33852 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_uint32_set",&obj0,&obj1)) SWIG_fail;
33853 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33854 0 : if (!SWIG_IsOK(res1)) {
33855 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33856 : }
33857 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33858 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
33859 0 : if (!SWIG_IsOK(ecode2)) {
33860 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_uint32_set" "', argument " "2"" of type '" "unsigned int""'");
33861 : }
33862 0 : arg2 = (unsigned int)(val2);
33863 : {
33864 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33865 0 : if (arg1) (arg1)->uint32 = arg2;
33866 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33867 : }
33868 0 : resultobj = SWIG_Py_Void();
33869 0 : return resultobj;
33870 : fail:
33871 : return NULL;
33872 : }
33873 :
33874 :
33875 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_uint32_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33876 0 : PyObject *resultobj = 0;
33877 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33878 0 : void *argp1 = 0 ;
33879 0 : int res1 = 0 ;
33880 0 : PyObject * obj0 = 0 ;
33881 : unsigned int result;
33882 :
33883 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_uint32_get",&obj0)) SWIG_fail;
33884 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33885 0 : if (!SWIG_IsOK(res1)) {
33886 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_uint32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33887 : }
33888 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33889 : {
33890 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33891 0 : result = (unsigned int) ((arg1)->uint32);
33892 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33893 : }
33894 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
33895 0 : return resultobj;
33896 : fail:
33897 : return NULL;
33898 : }
33899 :
33900 :
33901 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33902 0 : PyObject *resultobj = 0;
33903 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33904 : int arg2 ;
33905 0 : void *argp1 = 0 ;
33906 0 : int res1 = 0 ;
33907 : int val2 ;
33908 0 : int ecode2 = 0 ;
33909 0 : PyObject * obj0 = 0 ;
33910 0 : PyObject * obj1 = 0 ;
33911 :
33912 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_int32_set",&obj0,&obj1)) SWIG_fail;
33913 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33914 0 : if (!SWIG_IsOK(res1)) {
33915 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33916 : }
33917 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33918 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
33919 0 : if (!SWIG_IsOK(ecode2)) {
33920 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_value_int32_set" "', argument " "2"" of type '" "int""'");
33921 : }
33922 0 : arg2 = (int)(val2);
33923 : {
33924 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33925 0 : if (arg1) (arg1)->int32 = arg2;
33926 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33927 : }
33928 0 : resultobj = SWIG_Py_Void();
33929 0 : return resultobj;
33930 : fail:
33931 : return NULL;
33932 : }
33933 :
33934 :
33935 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_int32_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33936 0 : PyObject *resultobj = 0;
33937 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33938 0 : void *argp1 = 0 ;
33939 0 : int res1 = 0 ;
33940 0 : PyObject * obj0 = 0 ;
33941 : int result;
33942 :
33943 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_int32_get",&obj0)) SWIG_fail;
33944 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33945 0 : if (!SWIG_IsOK(res1)) {
33946 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_int32_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33947 : }
33948 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33949 : {
33950 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33951 0 : result = (int) ((arg1)->int32);
33952 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33953 : }
33954 0 : resultobj = SWIG_From_int((int)(result));
33955 0 : return resultobj;
33956 : fail:
33957 : return NULL;
33958 : }
33959 :
33960 :
33961 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33962 0 : PyObject *resultobj = 0;
33963 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
33964 0 : char *arg2 = (char *) 0 ;
33965 0 : void *argp1 = 0 ;
33966 0 : int res1 = 0 ;
33967 : int res2 ;
33968 0 : char *buf2 = 0 ;
33969 0 : int alloc2 = 0 ;
33970 0 : PyObject * obj0 = 0 ;
33971 0 : PyObject * obj1 = 0 ;
33972 :
33973 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_value_string_set",&obj0,&obj1)) SWIG_fail;
33974 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
33975 0 : if (!SWIG_IsOK(res1)) {
33976 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
33977 : }
33978 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
33979 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
33980 0 : if (!SWIG_IsOK(res2)) {
33981 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_arg_value_string_set" "', argument " "2"" of type '" "char *""'");
33982 : }
33983 0 : arg2 = (char *)(buf2);
33984 : {
33985 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
33986 0 : if (arg1->string) free((char*)arg1->string);
33987 0 : if (arg2) {
33988 0 : size_t size = strlen((const char *)(arg2)) + 1;
33989 0 : arg1->string = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
33990 : } else {
33991 0 : arg1->string = 0;
33992 : }
33993 0 : SWIG_PYTHON_THREAD_END_ALLOW;
33994 : }
33995 0 : resultobj = SWIG_Py_Void();
33996 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
33997 : return resultobj;
33998 : fail:
33999 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34000 : return NULL;
34001 : }
34002 :
34003 :
34004 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_value_string_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34005 0 : PyObject *resultobj = 0;
34006 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
34007 0 : void *argp1 = 0 ;
34008 0 : int res1 = 0 ;
34009 0 : PyObject * obj0 = 0 ;
34010 0 : char *result = 0 ;
34011 :
34012 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_arg_value_string_get",&obj0)) SWIG_fail;
34013 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, 0 | 0 );
34014 0 : if (!SWIG_IsOK(res1)) {
34015 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_value_string_get" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
34016 : }
34017 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
34018 : {
34019 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34020 0 : result = (char *) ((arg1)->string);
34021 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34022 : }
34023 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34024 0 : return resultobj;
34025 : fail:
34026 : return NULL;
34027 : }
34028 :
34029 :
34030 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_arg_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34031 0 : PyObject *resultobj = 0;
34032 0 : gpgme_conf_arg_value *result = 0 ;
34033 :
34034 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_arg_value")) SWIG_fail;
34035 : {
34036 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34037 0 : result = (gpgme_conf_arg_value *)calloc(1, sizeof(gpgme_conf_arg_value));
34038 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34039 : }
34040 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_arg_value, SWIG_POINTER_NEW | 0 );
34041 0 : return resultobj;
34042 : fail:
34043 : return NULL;
34044 : }
34045 :
34046 :
34047 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_arg_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34048 0 : PyObject *resultobj = 0;
34049 0 : gpgme_conf_arg_value *arg1 = (gpgme_conf_arg_value *) 0 ;
34050 0 : void *argp1 = 0 ;
34051 0 : int res1 = 0 ;
34052 0 : PyObject * obj0 = 0 ;
34053 :
34054 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_arg_value",&obj0)) SWIG_fail;
34055 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg_value, SWIG_POINTER_DISOWN | 0 );
34056 0 : if (!SWIG_IsOK(res1)) {
34057 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_arg_value" "', argument " "1"" of type '" "gpgme_conf_arg_value *""'");
34058 : }
34059 0 : arg1 = (gpgme_conf_arg_value *)(argp1);
34060 : {
34061 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34062 0 : free((char *) arg1);
34063 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34064 : }
34065 0 : resultobj = SWIG_Py_Void();
34066 0 : return resultobj;
34067 : fail:
34068 : return NULL;
34069 : }
34070 :
34071 :
34072 27 : SWIGINTERN PyObject *gpgme_conf_arg_value_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34073 : PyObject *obj;
34074 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
34075 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_arg_value, SWIG_NewClientData(obj));
34076 27 : return SWIG_Py_Void();
34077 : }
34078 :
34079 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34080 0 : PyObject *resultobj = 0;
34081 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34082 0 : char *arg2 = (char *) 0 ;
34083 0 : void *argp1 = 0 ;
34084 0 : int res1 = 0 ;
34085 : int res2 ;
34086 0 : char *buf2 = 0 ;
34087 0 : int alloc2 = 0 ;
34088 0 : PyObject * obj0 = 0 ;
34089 0 : PyObject * obj1 = 0 ;
34090 :
34091 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_name_set",&obj0,&obj1)) SWIG_fail;
34092 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34093 0 : if (!SWIG_IsOK(res1)) {
34094 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34095 : }
34096 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34097 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34098 0 : if (!SWIG_IsOK(res2)) {
34099 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_name_set" "', argument " "2"" of type '" "char *""'");
34100 : }
34101 0 : arg2 = (char *)(buf2);
34102 : {
34103 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34104 0 : if (arg1->name) free((char*)arg1->name);
34105 0 : if (arg2) {
34106 0 : size_t size = strlen((const char *)(arg2)) + 1;
34107 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
34108 : } else {
34109 0 : arg1->name = 0;
34110 : }
34111 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34112 : }
34113 0 : resultobj = SWIG_Py_Void();
34114 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34115 : return resultobj;
34116 : fail:
34117 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34118 : return NULL;
34119 : }
34120 :
34121 :
34122 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34123 0 : PyObject *resultobj = 0;
34124 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34125 0 : void *argp1 = 0 ;
34126 0 : int res1 = 0 ;
34127 0 : PyObject * obj0 = 0 ;
34128 0 : char *result = 0 ;
34129 :
34130 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_name_get",&obj0)) SWIG_fail;
34131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34132 0 : if (!SWIG_IsOK(res1)) {
34133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_name_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34134 : }
34135 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34136 : {
34137 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34138 0 : result = (char *) ((arg1)->name);
34139 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34140 : }
34141 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34142 0 : return resultobj;
34143 : fail:
34144 : return NULL;
34145 : }
34146 :
34147 :
34148 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34149 0 : PyObject *resultobj = 0;
34150 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34151 : unsigned int arg2 ;
34152 0 : void *argp1 = 0 ;
34153 0 : int res1 = 0 ;
34154 : unsigned int val2 ;
34155 0 : int ecode2 = 0 ;
34156 0 : PyObject * obj0 = 0 ;
34157 0 : PyObject * obj1 = 0 ;
34158 :
34159 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_flags_set",&obj0,&obj1)) SWIG_fail;
34160 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34161 0 : if (!SWIG_IsOK(res1)) {
34162 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34163 : }
34164 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34165 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
34166 0 : if (!SWIG_IsOK(ecode2)) {
34167 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_flags_set" "', argument " "2"" of type '" "unsigned int""'");
34168 : }
34169 0 : arg2 = (unsigned int)(val2);
34170 : {
34171 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34172 0 : if (arg1) (arg1)->flags = arg2;
34173 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34174 : }
34175 0 : resultobj = SWIG_Py_Void();
34176 0 : return resultobj;
34177 : fail:
34178 : return NULL;
34179 : }
34180 :
34181 :
34182 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_flags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34183 0 : PyObject *resultobj = 0;
34184 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34185 0 : void *argp1 = 0 ;
34186 0 : int res1 = 0 ;
34187 0 : PyObject * obj0 = 0 ;
34188 : unsigned int result;
34189 :
34190 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_flags_get",&obj0)) SWIG_fail;
34191 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34192 0 : if (!SWIG_IsOK(res1)) {
34193 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_flags_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34194 : }
34195 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34196 : {
34197 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34198 0 : result = (unsigned int) ((arg1)->flags);
34199 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34200 : }
34201 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
34202 0 : return resultobj;
34203 : fail:
34204 : return NULL;
34205 : }
34206 :
34207 :
34208 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34209 0 : PyObject *resultobj = 0;
34210 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34211 : gpgme_conf_level_t arg2 ;
34212 0 : void *argp1 = 0 ;
34213 0 : int res1 = 0 ;
34214 : int val2 ;
34215 0 : int ecode2 = 0 ;
34216 0 : PyObject * obj0 = 0 ;
34217 0 : PyObject * obj1 = 0 ;
34218 :
34219 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_level_set",&obj0,&obj1)) SWIG_fail;
34220 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34221 0 : if (!SWIG_IsOK(res1)) {
34222 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34223 : }
34224 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34225 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34226 0 : if (!SWIG_IsOK(ecode2)) {
34227 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_level_set" "', argument " "2"" of type '" "gpgme_conf_level_t""'");
34228 : }
34229 0 : arg2 = (gpgme_conf_level_t)(val2);
34230 : {
34231 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34232 0 : if (arg1) (arg1)->level = arg2;
34233 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34234 : }
34235 0 : resultobj = SWIG_Py_Void();
34236 0 : return resultobj;
34237 : fail:
34238 : return NULL;
34239 : }
34240 :
34241 :
34242 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_level_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34243 0 : PyObject *resultobj = 0;
34244 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34245 0 : void *argp1 = 0 ;
34246 0 : int res1 = 0 ;
34247 0 : PyObject * obj0 = 0 ;
34248 : gpgme_conf_level_t result;
34249 :
34250 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_level_get",&obj0)) SWIG_fail;
34251 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34252 0 : if (!SWIG_IsOK(res1)) {
34253 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_level_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34254 : }
34255 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34256 : {
34257 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34258 0 : result = (gpgme_conf_level_t) ((arg1)->level);
34259 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34260 : }
34261 0 : resultobj = SWIG_From_int((int)(result));
34262 0 : return resultobj;
34263 : fail:
34264 : return NULL;
34265 : }
34266 :
34267 :
34268 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34269 0 : PyObject *resultobj = 0;
34270 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34271 0 : char *arg2 = (char *) 0 ;
34272 0 : void *argp1 = 0 ;
34273 0 : int res1 = 0 ;
34274 : int res2 ;
34275 0 : char *buf2 = 0 ;
34276 0 : int alloc2 = 0 ;
34277 0 : PyObject * obj0 = 0 ;
34278 0 : PyObject * obj1 = 0 ;
34279 :
34280 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_description_set",&obj0,&obj1)) SWIG_fail;
34281 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34282 0 : if (!SWIG_IsOK(res1)) {
34283 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34284 : }
34285 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34286 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34287 0 : if (!SWIG_IsOK(res2)) {
34288 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_description_set" "', argument " "2"" of type '" "char *""'");
34289 : }
34290 0 : arg2 = (char *)(buf2);
34291 : {
34292 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34293 0 : if (arg1->description) free((char*)arg1->description);
34294 0 : if (arg2) {
34295 0 : size_t size = strlen((const char *)(arg2)) + 1;
34296 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
34297 : } else {
34298 0 : arg1->description = 0;
34299 : }
34300 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34301 : }
34302 0 : resultobj = SWIG_Py_Void();
34303 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34304 : return resultobj;
34305 : fail:
34306 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34307 : return NULL;
34308 : }
34309 :
34310 :
34311 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34312 0 : PyObject *resultobj = 0;
34313 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34314 0 : void *argp1 = 0 ;
34315 0 : int res1 = 0 ;
34316 0 : PyObject * obj0 = 0 ;
34317 0 : char *result = 0 ;
34318 :
34319 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_description_get",&obj0)) SWIG_fail;
34320 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34321 0 : if (!SWIG_IsOK(res1)) {
34322 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34323 : }
34324 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34325 : {
34326 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34327 0 : result = (char *) ((arg1)->description);
34328 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34329 : }
34330 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34331 0 : return resultobj;
34332 : fail:
34333 : return NULL;
34334 : }
34335 :
34336 :
34337 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34338 0 : PyObject *resultobj = 0;
34339 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34340 : gpgme_conf_type_t arg2 ;
34341 0 : void *argp1 = 0 ;
34342 0 : int res1 = 0 ;
34343 : int val2 ;
34344 0 : int ecode2 = 0 ;
34345 0 : PyObject * obj0 = 0 ;
34346 0 : PyObject * obj1 = 0 ;
34347 :
34348 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_type_set",&obj0,&obj1)) SWIG_fail;
34349 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34350 0 : if (!SWIG_IsOK(res1)) {
34351 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34352 : }
34353 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34354 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34355 0 : if (!SWIG_IsOK(ecode2)) {
34356 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
34357 : }
34358 0 : arg2 = (gpgme_conf_type_t)(val2);
34359 : {
34360 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34361 0 : if (arg1) (arg1)->type = arg2;
34362 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34363 : }
34364 0 : resultobj = SWIG_Py_Void();
34365 0 : return resultobj;
34366 : fail:
34367 : return NULL;
34368 : }
34369 :
34370 :
34371 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34372 0 : PyObject *resultobj = 0;
34373 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34374 0 : void *argp1 = 0 ;
34375 0 : int res1 = 0 ;
34376 0 : PyObject * obj0 = 0 ;
34377 : gpgme_conf_type_t result;
34378 :
34379 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_type_get",&obj0)) SWIG_fail;
34380 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34381 0 : if (!SWIG_IsOK(res1)) {
34382 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34383 : }
34384 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34385 : {
34386 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34387 0 : result = (gpgme_conf_type_t) ((arg1)->type);
34388 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34389 : }
34390 0 : resultobj = SWIG_From_int((int)(result));
34391 0 : return resultobj;
34392 : fail:
34393 : return NULL;
34394 : }
34395 :
34396 :
34397 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34398 0 : PyObject *resultobj = 0;
34399 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34400 : gpgme_conf_type_t arg2 ;
34401 0 : void *argp1 = 0 ;
34402 0 : int res1 = 0 ;
34403 : int val2 ;
34404 0 : int ecode2 = 0 ;
34405 0 : PyObject * obj0 = 0 ;
34406 0 : PyObject * obj1 = 0 ;
34407 :
34408 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_alt_type_set",&obj0,&obj1)) SWIG_fail;
34409 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34410 0 : if (!SWIG_IsOK(res1)) {
34411 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34412 : }
34413 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34414 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34415 0 : if (!SWIG_IsOK(ecode2)) {
34416 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_alt_type_set" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
34417 : }
34418 0 : arg2 = (gpgme_conf_type_t)(val2);
34419 : {
34420 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34421 0 : if (arg1) (arg1)->alt_type = arg2;
34422 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34423 : }
34424 0 : resultobj = SWIG_Py_Void();
34425 0 : return resultobj;
34426 : fail:
34427 : return NULL;
34428 : }
34429 :
34430 :
34431 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_alt_type_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34432 0 : PyObject *resultobj = 0;
34433 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34434 0 : void *argp1 = 0 ;
34435 0 : int res1 = 0 ;
34436 0 : PyObject * obj0 = 0 ;
34437 : gpgme_conf_type_t result;
34438 :
34439 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_alt_type_get",&obj0)) SWIG_fail;
34440 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34441 0 : if (!SWIG_IsOK(res1)) {
34442 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_alt_type_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34443 : }
34444 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34445 : {
34446 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34447 0 : result = (gpgme_conf_type_t) ((arg1)->alt_type);
34448 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34449 : }
34450 0 : resultobj = SWIG_From_int((int)(result));
34451 0 : return resultobj;
34452 : fail:
34453 : return NULL;
34454 : }
34455 :
34456 :
34457 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 0 : PyObject *resultobj = 0;
34459 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34460 0 : char *arg2 = (char *) 0 ;
34461 0 : void *argp1 = 0 ;
34462 0 : int res1 = 0 ;
34463 : int res2 ;
34464 0 : char *buf2 = 0 ;
34465 0 : int alloc2 = 0 ;
34466 0 : PyObject * obj0 = 0 ;
34467 0 : PyObject * obj1 = 0 ;
34468 :
34469 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_argname_set",&obj0,&obj1)) SWIG_fail;
34470 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34471 0 : if (!SWIG_IsOK(res1)) {
34472 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34473 : }
34474 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34475 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34476 0 : if (!SWIG_IsOK(res2)) {
34477 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_argname_set" "', argument " "2"" of type '" "char *""'");
34478 : }
34479 0 : arg2 = (char *)(buf2);
34480 : {
34481 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34482 0 : if (arg1->argname) free((char*)arg1->argname);
34483 0 : if (arg2) {
34484 0 : size_t size = strlen((const char *)(arg2)) + 1;
34485 0 : arg1->argname = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
34486 : } else {
34487 0 : arg1->argname = 0;
34488 : }
34489 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34490 : }
34491 0 : resultobj = SWIG_Py_Void();
34492 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34493 : return resultobj;
34494 : fail:
34495 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34496 : return NULL;
34497 : }
34498 :
34499 :
34500 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_argname_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34501 0 : PyObject *resultobj = 0;
34502 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34503 0 : void *argp1 = 0 ;
34504 0 : int res1 = 0 ;
34505 0 : PyObject * obj0 = 0 ;
34506 0 : char *result = 0 ;
34507 :
34508 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_argname_get",&obj0)) SWIG_fail;
34509 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34510 0 : if (!SWIG_IsOK(res1)) {
34511 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_argname_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34512 : }
34513 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34514 : {
34515 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34516 0 : result = (char *) ((arg1)->argname);
34517 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34518 : }
34519 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34520 0 : return resultobj;
34521 : fail:
34522 : return NULL;
34523 : }
34524 :
34525 :
34526 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 0 : PyObject *resultobj = 0;
34528 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34529 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
34530 0 : void *argp1 = 0 ;
34531 0 : int res1 = 0 ;
34532 0 : void *argp2 = 0 ;
34533 0 : int res2 = 0 ;
34534 0 : PyObject * obj0 = 0 ;
34535 0 : PyObject * obj1 = 0 ;
34536 :
34537 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_default_value_set",&obj0,&obj1)) SWIG_fail;
34538 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34539 0 : if (!SWIG_IsOK(res1)) {
34540 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34541 : }
34542 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34543 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
34544 0 : if (!SWIG_IsOK(res2)) {
34545 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
34546 : }
34547 0 : arg2 = (gpgme_conf_arg_t)(argp2);
34548 : {
34549 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34550 0 : if (arg1) (arg1)->default_value = arg2;
34551 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34552 : }
34553 0 : resultobj = SWIG_Py_Void();
34554 0 : return resultobj;
34555 : fail:
34556 : return NULL;
34557 : }
34558 :
34559 :
34560 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34561 0 : PyObject *resultobj = 0;
34562 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34563 0 : void *argp1 = 0 ;
34564 0 : int res1 = 0 ;
34565 0 : PyObject * obj0 = 0 ;
34566 : gpgme_conf_arg_t result;
34567 :
34568 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_value_get",&obj0)) SWIG_fail;
34569 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34570 0 : if (!SWIG_IsOK(res1)) {
34571 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34572 : }
34573 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34574 : {
34575 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34576 0 : result = (gpgme_conf_arg_t) ((arg1)->default_value);
34577 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34578 : }
34579 : {
34580 : int i;
34581 0 : int size = 0;
34582 : gpgme_conf_arg_t curr;
34583 0 : for (curr = result; curr != NULL; curr = curr->next) {
34584 0 : size++;
34585 : }
34586 0 : resultobj = PyList_New(size);
34587 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
34588 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
34589 0 : PyList_SetItem(resultobj, i, o);
34590 : }
34591 : }
34592 : return resultobj;
34593 : fail:
34594 : return NULL;
34595 : }
34596 :
34597 :
34598 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34599 0 : PyObject *resultobj = 0;
34600 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34601 0 : char *arg2 = (char *) 0 ;
34602 0 : void *argp1 = 0 ;
34603 0 : int res1 = 0 ;
34604 : int res2 ;
34605 0 : char *buf2 = 0 ;
34606 0 : int alloc2 = 0 ;
34607 0 : PyObject * obj0 = 0 ;
34608 0 : PyObject * obj1 = 0 ;
34609 :
34610 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_default_description_set",&obj0,&obj1)) SWIG_fail;
34611 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34612 0 : if (!SWIG_IsOK(res1)) {
34613 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34614 : }
34615 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34616 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34617 0 : if (!SWIG_IsOK(res2)) {
34618 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_default_description_set" "', argument " "2"" of type '" "char *""'");
34619 : }
34620 0 : arg2 = (char *)(buf2);
34621 : {
34622 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34623 0 : if (arg1->default_description) free((char*)arg1->default_description);
34624 0 : if (arg2) {
34625 0 : size_t size = strlen((const char *)(arg2)) + 1;
34626 0 : arg1->default_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
34627 : } else {
34628 0 : arg1->default_description = 0;
34629 : }
34630 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34631 : }
34632 0 : resultobj = SWIG_Py_Void();
34633 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34634 : return resultobj;
34635 : fail:
34636 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34637 : return NULL;
34638 : }
34639 :
34640 :
34641 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_default_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34642 0 : PyObject *resultobj = 0;
34643 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34644 0 : void *argp1 = 0 ;
34645 0 : int res1 = 0 ;
34646 0 : PyObject * obj0 = 0 ;
34647 0 : char *result = 0 ;
34648 :
34649 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_default_description_get",&obj0)) SWIG_fail;
34650 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34651 0 : if (!SWIG_IsOK(res1)) {
34652 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_default_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34653 : }
34654 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34655 : {
34656 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34657 0 : result = (char *) ((arg1)->default_description);
34658 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34659 : }
34660 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34661 0 : return resultobj;
34662 : fail:
34663 : return NULL;
34664 : }
34665 :
34666 :
34667 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34668 0 : PyObject *resultobj = 0;
34669 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34670 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
34671 0 : void *argp1 = 0 ;
34672 0 : int res1 = 0 ;
34673 0 : void *argp2 = 0 ;
34674 0 : int res2 = 0 ;
34675 0 : PyObject * obj0 = 0 ;
34676 0 : PyObject * obj1 = 0 ;
34677 :
34678 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_no_arg_value_set",&obj0,&obj1)) SWIG_fail;
34679 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34680 0 : if (!SWIG_IsOK(res1)) {
34681 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34682 : }
34683 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34684 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
34685 0 : if (!SWIG_IsOK(res2)) {
34686 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
34687 : }
34688 0 : arg2 = (gpgme_conf_arg_t)(argp2);
34689 : {
34690 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34691 0 : if (arg1) (arg1)->no_arg_value = arg2;
34692 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34693 : }
34694 0 : resultobj = SWIG_Py_Void();
34695 0 : return resultobj;
34696 : fail:
34697 : return NULL;
34698 : }
34699 :
34700 :
34701 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34702 0 : PyObject *resultobj = 0;
34703 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34704 0 : void *argp1 = 0 ;
34705 0 : int res1 = 0 ;
34706 0 : PyObject * obj0 = 0 ;
34707 : gpgme_conf_arg_t result;
34708 :
34709 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_value_get",&obj0)) SWIG_fail;
34710 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34711 0 : if (!SWIG_IsOK(res1)) {
34712 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34713 : }
34714 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34715 : {
34716 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34717 0 : result = (gpgme_conf_arg_t) ((arg1)->no_arg_value);
34718 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34719 : }
34720 : {
34721 : int i;
34722 0 : int size = 0;
34723 : gpgme_conf_arg_t curr;
34724 0 : for (curr = result; curr != NULL; curr = curr->next) {
34725 0 : size++;
34726 : }
34727 0 : resultobj = PyList_New(size);
34728 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
34729 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
34730 0 : PyList_SetItem(resultobj, i, o);
34731 : }
34732 : }
34733 : return resultobj;
34734 : fail:
34735 : return NULL;
34736 : }
34737 :
34738 :
34739 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34740 0 : PyObject *resultobj = 0;
34741 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34742 0 : char *arg2 = (char *) 0 ;
34743 0 : void *argp1 = 0 ;
34744 0 : int res1 = 0 ;
34745 : int res2 ;
34746 0 : char *buf2 = 0 ;
34747 0 : int alloc2 = 0 ;
34748 0 : PyObject * obj0 = 0 ;
34749 0 : PyObject * obj1 = 0 ;
34750 :
34751 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_no_arg_description_set",&obj0,&obj1)) SWIG_fail;
34752 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34753 0 : if (!SWIG_IsOK(res1)) {
34754 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34755 : }
34756 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34757 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
34758 0 : if (!SWIG_IsOK(res2)) {
34759 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_no_arg_description_set" "', argument " "2"" of type '" "char *""'");
34760 : }
34761 0 : arg2 = (char *)(buf2);
34762 : {
34763 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34764 0 : if (arg1->no_arg_description) free((char*)arg1->no_arg_description);
34765 0 : if (arg2) {
34766 0 : size_t size = strlen((const char *)(arg2)) + 1;
34767 0 : arg1->no_arg_description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
34768 : } else {
34769 0 : arg1->no_arg_description = 0;
34770 : }
34771 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34772 : }
34773 0 : resultobj = SWIG_Py_Void();
34774 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34775 : return resultobj;
34776 : fail:
34777 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
34778 : return NULL;
34779 : }
34780 :
34781 :
34782 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_no_arg_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34783 0 : PyObject *resultobj = 0;
34784 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34785 0 : void *argp1 = 0 ;
34786 0 : int res1 = 0 ;
34787 0 : PyObject * obj0 = 0 ;
34788 0 : char *result = 0 ;
34789 :
34790 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_no_arg_description_get",&obj0)) SWIG_fail;
34791 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34792 0 : if (!SWIG_IsOK(res1)) {
34793 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_no_arg_description_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34794 : }
34795 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34796 : {
34797 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34798 0 : result = (char *) ((arg1)->no_arg_description);
34799 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34800 : }
34801 0 : resultobj = SWIG_FromCharPtr((const char *)result);
34802 0 : return resultobj;
34803 : fail:
34804 : return NULL;
34805 : }
34806 :
34807 :
34808 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34809 0 : PyObject *resultobj = 0;
34810 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34811 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
34812 0 : void *argp1 = 0 ;
34813 0 : int res1 = 0 ;
34814 0 : void *argp2 = 0 ;
34815 0 : int res2 = 0 ;
34816 0 : PyObject * obj0 = 0 ;
34817 0 : PyObject * obj1 = 0 ;
34818 :
34819 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_value_set",&obj0,&obj1)) SWIG_fail;
34820 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34821 0 : if (!SWIG_IsOK(res1)) {
34822 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34823 : }
34824 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34825 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
34826 0 : if (!SWIG_IsOK(res2)) {
34827 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
34828 : }
34829 0 : arg2 = (gpgme_conf_arg_t)(argp2);
34830 : {
34831 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34832 0 : if (arg1) (arg1)->value = arg2;
34833 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34834 : }
34835 0 : resultobj = SWIG_Py_Void();
34836 0 : return resultobj;
34837 : fail:
34838 : return NULL;
34839 : }
34840 :
34841 :
34842 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34843 0 : PyObject *resultobj = 0;
34844 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34845 0 : void *argp1 = 0 ;
34846 0 : int res1 = 0 ;
34847 0 : PyObject * obj0 = 0 ;
34848 : gpgme_conf_arg_t result;
34849 :
34850 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_value_get",&obj0)) SWIG_fail;
34851 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34852 0 : if (!SWIG_IsOK(res1)) {
34853 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34854 : }
34855 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34856 : {
34857 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34858 0 : result = (gpgme_conf_arg_t) ((arg1)->value);
34859 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34860 : }
34861 : {
34862 : int i;
34863 0 : int size = 0;
34864 : gpgme_conf_arg_t curr;
34865 0 : for (curr = result; curr != NULL; curr = curr->next) {
34866 0 : size++;
34867 : }
34868 0 : resultobj = PyList_New(size);
34869 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
34870 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
34871 0 : PyList_SetItem(resultobj, i, o);
34872 : }
34873 : }
34874 : return resultobj;
34875 : fail:
34876 : return NULL;
34877 : }
34878 :
34879 :
34880 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34881 0 : PyObject *resultobj = 0;
34882 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34883 : int arg2 ;
34884 0 : void *argp1 = 0 ;
34885 0 : int res1 = 0 ;
34886 : int val2 ;
34887 0 : int ecode2 = 0 ;
34888 0 : PyObject * obj0 = 0 ;
34889 0 : PyObject * obj1 = 0 ;
34890 :
34891 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_change_value_set",&obj0,&obj1)) SWIG_fail;
34892 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34893 0 : if (!SWIG_IsOK(res1)) {
34894 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34895 : }
34896 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34897 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
34898 0 : if (!SWIG_IsOK(ecode2)) {
34899 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change_value_set" "', argument " "2"" of type '" "int""'");
34900 : }
34901 0 : arg2 = (int)(val2);
34902 : {
34903 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34904 0 : if (arg1) (arg1)->change_value = arg2;
34905 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34906 : }
34907 0 : resultobj = SWIG_Py_Void();
34908 0 : return resultobj;
34909 : fail:
34910 : return NULL;
34911 : }
34912 :
34913 :
34914 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34915 0 : PyObject *resultobj = 0;
34916 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34917 0 : void *argp1 = 0 ;
34918 0 : int res1 = 0 ;
34919 0 : PyObject * obj0 = 0 ;
34920 : int result;
34921 :
34922 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_change_value_get",&obj0)) SWIG_fail;
34923 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34924 0 : if (!SWIG_IsOK(res1)) {
34925 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34926 : }
34927 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34928 : {
34929 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34930 0 : result = (int) ((arg1)->change_value);
34931 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34932 : }
34933 0 : resultobj = SWIG_From_int((int)(result));
34934 0 : return resultobj;
34935 : fail:
34936 : return NULL;
34937 : }
34938 :
34939 :
34940 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34941 0 : PyObject *resultobj = 0;
34942 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34943 0 : gpgme_conf_arg_t arg2 = (gpgme_conf_arg_t) 0 ;
34944 0 : void *argp1 = 0 ;
34945 0 : int res1 = 0 ;
34946 0 : void *argp2 = 0 ;
34947 0 : int res2 = 0 ;
34948 0 : PyObject * obj0 = 0 ;
34949 0 : PyObject * obj1 = 0 ;
34950 :
34951 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_new_value_set",&obj0,&obj1)) SWIG_fail;
34952 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34953 0 : if (!SWIG_IsOK(res1)) {
34954 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34955 : }
34956 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34957 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_arg, SWIG_POINTER_DISOWN | 0 );
34958 0 : if (!SWIG_IsOK(res2)) {
34959 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_new_value_set" "', argument " "2"" of type '" "gpgme_conf_arg_t""'");
34960 : }
34961 0 : arg2 = (gpgme_conf_arg_t)(argp2);
34962 : {
34963 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34964 0 : if (arg1) (arg1)->new_value = arg2;
34965 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34966 : }
34967 0 : resultobj = SWIG_Py_Void();
34968 0 : return resultobj;
34969 : fail:
34970 : return NULL;
34971 : }
34972 :
34973 :
34974 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_new_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34975 0 : PyObject *resultobj = 0;
34976 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
34977 0 : void *argp1 = 0 ;
34978 0 : int res1 = 0 ;
34979 0 : PyObject * obj0 = 0 ;
34980 : gpgme_conf_arg_t result;
34981 :
34982 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_new_value_get",&obj0)) SWIG_fail;
34983 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
34984 0 : if (!SWIG_IsOK(res1)) {
34985 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_new_value_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
34986 : }
34987 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
34988 : {
34989 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
34990 0 : result = (gpgme_conf_arg_t) ((arg1)->new_value);
34991 0 : SWIG_PYTHON_THREAD_END_ALLOW;
34992 : }
34993 : {
34994 : int i;
34995 0 : int size = 0;
34996 : gpgme_conf_arg_t curr;
34997 0 : for (curr = result; curr != NULL; curr = curr->next) {
34998 0 : size++;
34999 : }
35000 0 : resultobj = PyList_New(size);
35001 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
35002 0 : PyObject *o = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p_gpgme_conf_arg, 0 );
35003 0 : PyList_SetItem(resultobj, i, o);
35004 : }
35005 : }
35006 : return resultobj;
35007 : fail:
35008 : return NULL;
35009 : }
35010 :
35011 :
35012 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35013 0 : PyObject *resultobj = 0;
35014 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
35015 0 : void *arg2 = (void *) 0 ;
35016 0 : void *argp1 = 0 ;
35017 0 : int res1 = 0 ;
35018 : int res2 ;
35019 0 : PyObject * obj0 = 0 ;
35020 0 : PyObject * obj1 = 0 ;
35021 :
35022 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_opt_user_data_set",&obj0,&obj1)) SWIG_fail;
35023 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
35024 0 : if (!SWIG_IsOK(res1)) {
35025 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
35026 : }
35027 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
35028 0 : res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
35029 0 : if (!SWIG_IsOK(res2)) {
35030 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_opt_user_data_set" "', argument " "2"" of type '" "void *""'");
35031 : }
35032 : {
35033 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35034 0 : if (arg1) (arg1)->user_data = arg2;
35035 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35036 : }
35037 0 : resultobj = SWIG_Py_Void();
35038 0 : return resultobj;
35039 : fail:
35040 : return NULL;
35041 : }
35042 :
35043 :
35044 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_user_data_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35045 0 : PyObject *resultobj = 0;
35046 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
35047 0 : void *argp1 = 0 ;
35048 0 : int res1 = 0 ;
35049 0 : PyObject * obj0 = 0 ;
35050 0 : void *result = 0 ;
35051 :
35052 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_opt_user_data_get",&obj0)) SWIG_fail;
35053 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
35054 0 : if (!SWIG_IsOK(res1)) {
35055 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_user_data_get" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
35056 : }
35057 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
35058 : {
35059 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35060 0 : result = (void *) ((arg1)->user_data);
35061 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35062 : }
35063 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 | 0 );
35064 0 : return resultobj;
35065 : fail:
35066 : return NULL;
35067 : }
35068 :
35069 :
35070 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35071 0 : PyObject *resultobj = 0;
35072 0 : struct gpgme_conf_opt *result = 0 ;
35073 :
35074 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_opt")) SWIG_fail;
35075 : {
35076 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35077 0 : result = (struct gpgme_conf_opt *)calloc(1, sizeof(struct gpgme_conf_opt));
35078 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35079 : }
35080 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_NEW | 0 );
35081 0 : return resultobj;
35082 : fail:
35083 : return NULL;
35084 : }
35085 :
35086 :
35087 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_opt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35088 0 : PyObject *resultobj = 0;
35089 0 : struct gpgme_conf_opt *arg1 = (struct gpgme_conf_opt *) 0 ;
35090 0 : void *argp1 = 0 ;
35091 0 : int res1 = 0 ;
35092 0 : PyObject * obj0 = 0 ;
35093 :
35094 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_opt",&obj0)) SWIG_fail;
35095 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
35096 0 : if (!SWIG_IsOK(res1)) {
35097 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_opt" "', argument " "1"" of type '" "struct gpgme_conf_opt *""'");
35098 : }
35099 0 : arg1 = (struct gpgme_conf_opt *)(argp1);
35100 : {
35101 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35102 0 : free((char *) arg1);
35103 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35104 : }
35105 0 : resultobj = SWIG_Py_Void();
35106 0 : return resultobj;
35107 : fail:
35108 : return NULL;
35109 : }
35110 :
35111 :
35112 27 : SWIGINTERN PyObject *gpgme_conf_opt_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35113 : PyObject *obj;
35114 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
35115 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_opt, SWIG_NewClientData(obj));
35116 27 : return SWIG_Py_Void();
35117 : }
35118 :
35119 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35120 0 : PyObject *resultobj = 0;
35121 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35122 0 : gpgme_conf_opt_t *arg2 = (gpgme_conf_opt_t *) 0 ;
35123 0 : void *argp1 = 0 ;
35124 0 : int res1 = 0 ;
35125 0 : void *argp2 = 0 ;
35126 0 : int res2 = 0 ;
35127 0 : PyObject * obj0 = 0 ;
35128 0 : PyObject * obj1 = 0 ;
35129 :
35130 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp__last_opt_p_set",&obj0,&obj1)) SWIG_fail;
35131 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35132 0 : if (!SWIG_IsOK(res1)) {
35133 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35134 : }
35135 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35136 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
35137 0 : if (!SWIG_IsOK(res2)) {
35138 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp__last_opt_p_set" "', argument " "2"" of type '" "gpgme_conf_opt_t *""'");
35139 : }
35140 0 : arg2 = (gpgme_conf_opt_t *)(argp2);
35141 : {
35142 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35143 0 : if (arg1) (arg1)->_last_opt_p = arg2;
35144 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35145 : }
35146 0 : resultobj = SWIG_Py_Void();
35147 0 : return resultobj;
35148 : fail:
35149 : return NULL;
35150 : }
35151 :
35152 :
35153 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp__last_opt_p_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35154 0 : PyObject *resultobj = 0;
35155 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35156 0 : void *argp1 = 0 ;
35157 0 : int res1 = 0 ;
35158 0 : PyObject * obj0 = 0 ;
35159 0 : gpgme_conf_opt_t *result = 0 ;
35160 :
35161 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp__last_opt_p_get",&obj0)) SWIG_fail;
35162 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35163 0 : if (!SWIG_IsOK(res1)) {
35164 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp__last_opt_p_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35165 : }
35166 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35167 : {
35168 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35169 0 : result = (gpgme_conf_opt_t *) ((arg1)->_last_opt_p);
35170 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35171 : }
35172 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_conf_opt, 0 | 0 );
35173 0 : return resultobj;
35174 : fail:
35175 : return NULL;
35176 : }
35177 :
35178 :
35179 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35180 0 : PyObject *resultobj = 0;
35181 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35182 0 : char *arg2 = (char *) 0 ;
35183 0 : void *argp1 = 0 ;
35184 0 : int res1 = 0 ;
35185 : int res2 ;
35186 0 : char *buf2 = 0 ;
35187 0 : int alloc2 = 0 ;
35188 0 : PyObject * obj0 = 0 ;
35189 0 : PyObject * obj1 = 0 ;
35190 :
35191 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_name_set",&obj0,&obj1)) SWIG_fail;
35192 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35193 0 : if (!SWIG_IsOK(res1)) {
35194 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35195 : }
35196 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35197 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35198 0 : if (!SWIG_IsOK(res2)) {
35199 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_name_set" "', argument " "2"" of type '" "char *""'");
35200 : }
35201 0 : arg2 = (char *)(buf2);
35202 : {
35203 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35204 0 : if (arg1->name) free((char*)arg1->name);
35205 0 : if (arg2) {
35206 0 : size_t size = strlen((const char *)(arg2)) + 1;
35207 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
35208 : } else {
35209 0 : arg1->name = 0;
35210 : }
35211 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35212 : }
35213 0 : resultobj = SWIG_Py_Void();
35214 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35215 : return resultobj;
35216 : fail:
35217 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35218 : return NULL;
35219 : }
35220 :
35221 :
35222 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35223 0 : PyObject *resultobj = 0;
35224 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35225 0 : void *argp1 = 0 ;
35226 0 : int res1 = 0 ;
35227 0 : PyObject * obj0 = 0 ;
35228 0 : char *result = 0 ;
35229 :
35230 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_name_get",&obj0)) SWIG_fail;
35231 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35232 0 : if (!SWIG_IsOK(res1)) {
35233 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35234 : }
35235 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35236 : {
35237 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35238 0 : result = (char *) ((arg1)->name);
35239 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35240 : }
35241 0 : resultobj = SWIG_FromCharPtr((const char *)result);
35242 0 : return resultobj;
35243 : fail:
35244 : return NULL;
35245 : }
35246 :
35247 :
35248 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35249 0 : PyObject *resultobj = 0;
35250 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35251 0 : char *arg2 = (char *) 0 ;
35252 0 : void *argp1 = 0 ;
35253 0 : int res1 = 0 ;
35254 : int res2 ;
35255 0 : char *buf2 = 0 ;
35256 0 : int alloc2 = 0 ;
35257 0 : PyObject * obj0 = 0 ;
35258 0 : PyObject * obj1 = 0 ;
35259 :
35260 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_description_set",&obj0,&obj1)) SWIG_fail;
35261 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35262 0 : if (!SWIG_IsOK(res1)) {
35263 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35264 : }
35265 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35266 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35267 0 : if (!SWIG_IsOK(res2)) {
35268 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_description_set" "', argument " "2"" of type '" "char *""'");
35269 : }
35270 0 : arg2 = (char *)(buf2);
35271 : {
35272 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35273 0 : if (arg1->description) free((char*)arg1->description);
35274 0 : if (arg2) {
35275 0 : size_t size = strlen((const char *)(arg2)) + 1;
35276 0 : arg1->description = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
35277 : } else {
35278 0 : arg1->description = 0;
35279 : }
35280 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35281 : }
35282 0 : resultobj = SWIG_Py_Void();
35283 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35284 : return resultobj;
35285 : fail:
35286 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35287 : return NULL;
35288 : }
35289 :
35290 :
35291 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_description_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35292 0 : PyObject *resultobj = 0;
35293 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35294 0 : void *argp1 = 0 ;
35295 0 : int res1 = 0 ;
35296 0 : PyObject * obj0 = 0 ;
35297 0 : char *result = 0 ;
35298 :
35299 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_description_get",&obj0)) SWIG_fail;
35300 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35301 0 : if (!SWIG_IsOK(res1)) {
35302 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_description_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35303 : }
35304 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35305 : {
35306 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35307 0 : result = (char *) ((arg1)->description);
35308 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35309 : }
35310 0 : resultobj = SWIG_FromCharPtr((const char *)result);
35311 0 : return resultobj;
35312 : fail:
35313 : return NULL;
35314 : }
35315 :
35316 :
35317 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35318 0 : PyObject *resultobj = 0;
35319 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35320 0 : char *arg2 = (char *) 0 ;
35321 0 : void *argp1 = 0 ;
35322 0 : int res1 = 0 ;
35323 : int res2 ;
35324 0 : char *buf2 = 0 ;
35325 0 : int alloc2 = 0 ;
35326 0 : PyObject * obj0 = 0 ;
35327 0 : PyObject * obj1 = 0 ;
35328 :
35329 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_program_name_set",&obj0,&obj1)) SWIG_fail;
35330 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35331 0 : if (!SWIG_IsOK(res1)) {
35332 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35333 : }
35334 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35335 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35336 0 : if (!SWIG_IsOK(res2)) {
35337 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_program_name_set" "', argument " "2"" of type '" "char *""'");
35338 : }
35339 0 : arg2 = (char *)(buf2);
35340 : {
35341 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35342 0 : if (arg1->program_name) free((char*)arg1->program_name);
35343 0 : if (arg2) {
35344 0 : size_t size = strlen((const char *)(arg2)) + 1;
35345 0 : arg1->program_name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
35346 : } else {
35347 0 : arg1->program_name = 0;
35348 : }
35349 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35350 : }
35351 0 : resultobj = SWIG_Py_Void();
35352 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35353 : return resultobj;
35354 : fail:
35355 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35356 : return NULL;
35357 : }
35358 :
35359 :
35360 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_program_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 0 : PyObject *resultobj = 0;
35362 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35363 0 : void *argp1 = 0 ;
35364 0 : int res1 = 0 ;
35365 0 : PyObject * obj0 = 0 ;
35366 0 : char *result = 0 ;
35367 :
35368 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_program_name_get",&obj0)) SWIG_fail;
35369 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35370 0 : if (!SWIG_IsOK(res1)) {
35371 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_program_name_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35372 : }
35373 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35374 : {
35375 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35376 0 : result = (char *) ((arg1)->program_name);
35377 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35378 : }
35379 0 : resultobj = SWIG_FromCharPtr((const char *)result);
35380 0 : return resultobj;
35381 : fail:
35382 : return NULL;
35383 : }
35384 :
35385 :
35386 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35387 0 : PyObject *resultobj = 0;
35388 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35389 0 : struct gpgme_conf_opt *arg2 = (struct gpgme_conf_opt *) 0 ;
35390 0 : void *argp1 = 0 ;
35391 0 : int res1 = 0 ;
35392 0 : void *argp2 = 0 ;
35393 0 : int res2 = 0 ;
35394 0 : PyObject * obj0 = 0 ;
35395 0 : PyObject * obj1 = 0 ;
35396 :
35397 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_comp_options_set",&obj0,&obj1)) SWIG_fail;
35398 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35399 0 : if (!SWIG_IsOK(res1)) {
35400 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_set" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35401 : }
35402 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35403 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_opt, SWIG_POINTER_DISOWN | 0 );
35404 0 : if (!SWIG_IsOK(res2)) {
35405 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_conf_comp_options_set" "', argument " "2"" of type '" "struct gpgme_conf_opt *""'");
35406 : }
35407 0 : arg2 = (struct gpgme_conf_opt *)(argp2);
35408 : {
35409 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35410 0 : if (arg1) (arg1)->options = arg2;
35411 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35412 : }
35413 0 : resultobj = SWIG_Py_Void();
35414 0 : return resultobj;
35415 : fail:
35416 : return NULL;
35417 : }
35418 :
35419 :
35420 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_comp_options_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35421 0 : PyObject *resultobj = 0;
35422 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35423 0 : void *argp1 = 0 ;
35424 0 : int res1 = 0 ;
35425 0 : PyObject * obj0 = 0 ;
35426 0 : struct gpgme_conf_opt *result = 0 ;
35427 :
35428 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_comp_options_get",&obj0)) SWIG_fail;
35429 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35430 0 : if (!SWIG_IsOK(res1)) {
35431 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_comp_options_get" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35432 : }
35433 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35434 : {
35435 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35436 0 : result = (struct gpgme_conf_opt *) ((arg1)->options);
35437 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35438 : }
35439 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
35440 0 : return resultobj;
35441 : fail:
35442 : return NULL;
35443 : }
35444 :
35445 :
35446 0 : SWIGINTERN PyObject *_wrap_new_gpgme_conf_comp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35447 0 : PyObject *resultobj = 0;
35448 0 : struct gpgme_conf_comp *result = 0 ;
35449 :
35450 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_conf_comp")) SWIG_fail;
35451 : {
35452 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35453 0 : result = (struct gpgme_conf_comp *)calloc(1, sizeof(struct gpgme_conf_comp));
35454 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35455 : }
35456 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_conf_comp, SWIG_POINTER_NEW | 0 );
35457 0 : return resultobj;
35458 : fail:
35459 : return NULL;
35460 : }
35461 :
35462 :
35463 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_conf_comp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35464 0 : PyObject *resultobj = 0;
35465 0 : struct gpgme_conf_comp *arg1 = (struct gpgme_conf_comp *) 0 ;
35466 0 : void *argp1 = 0 ;
35467 0 : int res1 = 0 ;
35468 0 : PyObject * obj0 = 0 ;
35469 :
35470 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_conf_comp",&obj0)) SWIG_fail;
35471 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, SWIG_POINTER_DISOWN | 0 );
35472 0 : if (!SWIG_IsOK(res1)) {
35473 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_conf_comp" "', argument " "1"" of type '" "struct gpgme_conf_comp *""'");
35474 : }
35475 0 : arg1 = (struct gpgme_conf_comp *)(argp1);
35476 : {
35477 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35478 0 : free((char *) arg1);
35479 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35480 : }
35481 0 : resultobj = SWIG_Py_Void();
35482 0 : return resultobj;
35483 : fail:
35484 : return NULL;
35485 : }
35486 :
35487 :
35488 27 : SWIGINTERN PyObject *gpgme_conf_comp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35489 : PyObject *obj;
35490 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
35491 54 : SWIG_TypeNewClientData(SWIGTYPE_p_gpgme_conf_comp, SWIG_NewClientData(obj));
35492 27 : return SWIG_Py_Void();
35493 : }
35494 :
35495 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_new(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35496 0 : PyObject *resultobj = 0;
35497 0 : gpgme_conf_arg_t *arg1 = (gpgme_conf_arg_t *) 0 ;
35498 : gpgme_conf_type_t arg2 ;
35499 0 : void *arg3 = (void *) 0 ;
35500 0 : void *argp1 = 0 ;
35501 0 : int res1 = 0 ;
35502 : int val2 ;
35503 0 : int ecode2 = 0 ;
35504 : int res3 ;
35505 0 : PyObject * obj0 = 0 ;
35506 0 : PyObject * obj1 = 0 ;
35507 0 : PyObject * obj2 = 0 ;
35508 : gpgme_error_t result;
35509 :
35510 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_arg_new",&obj0,&obj1,&obj2)) SWIG_fail;
35511 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_conf_arg, 0 | 0 );
35512 0 : if (!SWIG_IsOK(res1)) {
35513 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_new" "', argument " "1"" of type '" "gpgme_conf_arg_t *""'");
35514 : }
35515 0 : arg1 = (gpgme_conf_arg_t *)(argp1);
35516 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35517 0 : if (!SWIG_IsOK(ecode2)) {
35518 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_new" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
35519 : }
35520 0 : arg2 = (gpgme_conf_type_t)(val2);
35521 0 : res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3), 0, 0);
35522 0 : if (!SWIG_IsOK(res3)) {
35523 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_arg_new" "', argument " "3"" of type '" "void const *""'");
35524 : }
35525 : {
35526 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35527 0 : result = gpgme_conf_arg_new(arg1,arg2,(void const *)arg3);
35528 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35529 : }
35530 : {
35531 0 : resultobj = PyLong_FromLong(result);
35532 : }
35533 0 : return resultobj;
35534 : fail:
35535 : return NULL;
35536 : }
35537 :
35538 :
35539 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_arg_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35540 0 : PyObject *resultobj = 0;
35541 0 : gpgme_conf_arg_t arg1 = (gpgme_conf_arg_t) 0 ;
35542 : gpgme_conf_type_t arg2 ;
35543 0 : void *argp1 = 0 ;
35544 0 : int res1 = 0 ;
35545 : int val2 ;
35546 0 : int ecode2 = 0 ;
35547 0 : PyObject * obj0 = 0 ;
35548 0 : PyObject * obj1 = 0 ;
35549 :
35550 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_conf_arg_release",&obj0,&obj1)) SWIG_fail;
35551 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
35552 0 : if (!SWIG_IsOK(res1)) {
35553 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_arg_release" "', argument " "1"" of type '" "gpgme_conf_arg_t""'");
35554 : }
35555 0 : arg1 = (gpgme_conf_arg_t)(argp1);
35556 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35557 0 : if (!SWIG_IsOK(ecode2)) {
35558 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_arg_release" "', argument " "2"" of type '" "gpgme_conf_type_t""'");
35559 : }
35560 0 : arg2 = (gpgme_conf_type_t)(val2);
35561 : {
35562 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35563 0 : gpgme_conf_arg_release(arg1,arg2);
35564 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35565 : }
35566 0 : resultobj = SWIG_Py_Void();
35567 0 : return resultobj;
35568 : fail:
35569 : return NULL;
35570 : }
35571 :
35572 :
35573 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_opt_change(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35574 0 : PyObject *resultobj = 0;
35575 0 : gpgme_conf_opt_t arg1 = (gpgme_conf_opt_t) 0 ;
35576 : int arg2 ;
35577 0 : gpgme_conf_arg_t arg3 = (gpgme_conf_arg_t) 0 ;
35578 0 : void *argp1 = 0 ;
35579 0 : int res1 = 0 ;
35580 : int val2 ;
35581 0 : int ecode2 = 0 ;
35582 0 : void *argp3 = 0 ;
35583 0 : int res3 = 0 ;
35584 0 : PyObject * obj0 = 0 ;
35585 0 : PyObject * obj1 = 0 ;
35586 0 : PyObject * obj2 = 0 ;
35587 : gpgme_error_t result;
35588 :
35589 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_conf_opt_change",&obj0,&obj1,&obj2)) SWIG_fail;
35590 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_opt, 0 | 0 );
35591 0 : if (!SWIG_IsOK(res1)) {
35592 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_opt_change" "', argument " "1"" of type '" "gpgme_conf_opt_t""'");
35593 : }
35594 0 : arg1 = (gpgme_conf_opt_t)(argp1);
35595 0 : ecode2 = SWIG_AsVal_int(obj1, &val2);
35596 0 : if (!SWIG_IsOK(ecode2)) {
35597 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_conf_opt_change" "', argument " "2"" of type '" "int""'");
35598 : }
35599 0 : arg2 = (int)(val2);
35600 0 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_gpgme_conf_arg, 0 | 0 );
35601 0 : if (!SWIG_IsOK(res3)) {
35602 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpgme_conf_opt_change" "', argument " "3"" of type '" "gpgme_conf_arg_t""'");
35603 : }
35604 0 : arg3 = (gpgme_conf_arg_t)(argp3);
35605 : {
35606 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35607 0 : result = gpgme_conf_opt_change(arg1,arg2,arg3);
35608 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35609 : }
35610 : {
35611 0 : resultobj = PyLong_FromLong(result);
35612 : }
35613 0 : return resultobj;
35614 : fail:
35615 : return NULL;
35616 : }
35617 :
35618 :
35619 0 : SWIGINTERN PyObject *_wrap_gpgme_conf_release(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35620 0 : PyObject *resultobj = 0;
35621 0 : gpgme_conf_comp_t arg1 = (gpgme_conf_comp_t) 0 ;
35622 0 : void *argp1 = 0 ;
35623 0 : int res1 = 0 ;
35624 0 : PyObject * obj0 = 0 ;
35625 :
35626 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_conf_release",&obj0)) SWIG_fail;
35627 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35628 0 : if (!SWIG_IsOK(res1)) {
35629 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_conf_release" "', argument " "1"" of type '" "gpgme_conf_comp_t""'");
35630 : }
35631 0 : arg1 = (gpgme_conf_comp_t)(argp1);
35632 : {
35633 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35634 0 : gpgme_conf_release(arg1);
35635 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35636 : }
35637 0 : resultobj = SWIG_Py_Void();
35638 0 : return resultobj;
35639 : fail:
35640 : return NULL;
35641 : }
35642 :
35643 :
35644 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_load(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35645 0 : PyObject *resultobj = 0;
35646 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35647 0 : gpgme_conf_comp_t *arg2 = (gpgme_conf_comp_t *) 0 ;
35648 0 : void *argp1 = 0 ;
35649 0 : int res1 = 0 ;
35650 0 : void *argp2 = 0 ;
35651 0 : int res2 = 0 ;
35652 0 : PyObject * obj0 = 0 ;
35653 0 : PyObject * obj1 = 0 ;
35654 : gpgme_error_t result;
35655 :
35656 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_load",&obj0,&obj1)) SWIG_fail;
35657 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35658 0 : if (!SWIG_IsOK(res1)) {
35659 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_load" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35660 : }
35661 0 : arg1 = (gpgme_ctx_t)(argp1);
35662 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_p_gpgme_conf_comp, 0 | 0 );
35663 0 : if (!SWIG_IsOK(res2)) {
35664 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_load" "', argument " "2"" of type '" "gpgme_conf_comp_t *""'");
35665 : }
35666 0 : arg2 = (gpgme_conf_comp_t *)(argp2);
35667 : {
35668 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35669 0 : result = gpgme_op_conf_load(arg1,arg2);
35670 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35671 : }
35672 : {
35673 0 : resultobj = PyLong_FromLong(result);
35674 : }
35675 0 : return resultobj;
35676 : fail:
35677 : return NULL;
35678 : }
35679 :
35680 :
35681 0 : SWIGINTERN PyObject *_wrap_gpgme_op_conf_save(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35682 0 : PyObject *resultobj = 0;
35683 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
35684 0 : gpgme_conf_comp_t arg2 = (gpgme_conf_comp_t) 0 ;
35685 0 : void *argp1 = 0 ;
35686 0 : int res1 = 0 ;
35687 0 : void *argp2 = 0 ;
35688 0 : int res2 = 0 ;
35689 0 : PyObject * obj0 = 0 ;
35690 0 : PyObject * obj1 = 0 ;
35691 : gpgme_error_t result;
35692 :
35693 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_op_conf_save",&obj0,&obj1)) SWIG_fail;
35694 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
35695 0 : if (!SWIG_IsOK(res1)) {
35696 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_conf_save" "', argument " "1"" of type '" "gpgme_ctx_t""'");
35697 : }
35698 0 : arg1 = (gpgme_ctx_t)(argp1);
35699 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_conf_comp, 0 | 0 );
35700 0 : if (!SWIG_IsOK(res2)) {
35701 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_op_conf_save" "', argument " "2"" of type '" "gpgme_conf_comp_t""'");
35702 : }
35703 0 : arg2 = (gpgme_conf_comp_t)(argp2);
35704 : {
35705 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35706 0 : result = gpgme_op_conf_save(arg1,arg2);
35707 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35708 : }
35709 : {
35710 0 : resultobj = PyLong_FromLong(result);
35711 : }
35712 0 : return resultobj;
35713 : fail:
35714 : return NULL;
35715 : }
35716 :
35717 :
35718 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_name_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35719 0 : PyObject *resultobj = 0;
35720 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35721 0 : char *arg2 = (char *) 0 ;
35722 0 : void *argp1 = 0 ;
35723 0 : int res1 = 0 ;
35724 : int res2 ;
35725 0 : char *buf2 = 0 ;
35726 0 : int alloc2 = 0 ;
35727 0 : PyObject * obj0 = 0 ;
35728 0 : PyObject * obj1 = 0 ;
35729 :
35730 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_name_set",&obj0,&obj1)) SWIG_fail;
35731 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35732 0 : if (!SWIG_IsOK(res1)) {
35733 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_name_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35734 : }
35735 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35736 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35737 0 : if (!SWIG_IsOK(res2)) {
35738 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_name_set" "', argument " "2"" of type '" "char *""'");
35739 : }
35740 0 : arg2 = (char *)(buf2);
35741 : {
35742 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35743 0 : if (arg1->name) free((char*)arg1->name);
35744 0 : if (arg2) {
35745 0 : size_t size = strlen((const char *)(arg2)) + 1;
35746 0 : arg1->name = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
35747 : } else {
35748 0 : arg1->name = 0;
35749 : }
35750 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35751 : }
35752 0 : resultobj = SWIG_Py_Void();
35753 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35754 : return resultobj;
35755 : fail:
35756 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35757 : return NULL;
35758 : }
35759 :
35760 :
35761 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_name_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35762 0 : PyObject *resultobj = 0;
35763 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35764 0 : void *argp1 = 0 ;
35765 0 : int res1 = 0 ;
35766 0 : PyObject * obj0 = 0 ;
35767 0 : char *result = 0 ;
35768 :
35769 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_name_get",&obj0)) SWIG_fail;
35770 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35771 0 : if (!SWIG_IsOK(res1)) {
35772 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_name_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35773 : }
35774 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35775 : {
35776 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35777 0 : result = (char *) ((arg1)->name);
35778 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35779 : }
35780 0 : resultobj = SWIG_FromCharPtr((const char *)result);
35781 0 : return resultobj;
35782 : fail:
35783 : return NULL;
35784 : }
35785 :
35786 :
35787 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_iversion_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35788 0 : PyObject *resultobj = 0;
35789 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35790 0 : char *arg2 = (char *) 0 ;
35791 0 : void *argp1 = 0 ;
35792 0 : int res1 = 0 ;
35793 : int res2 ;
35794 0 : char *buf2 = 0 ;
35795 0 : int alloc2 = 0 ;
35796 0 : PyObject * obj0 = 0 ;
35797 0 : PyObject * obj1 = 0 ;
35798 :
35799 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_iversion_set",&obj0,&obj1)) SWIG_fail;
35800 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35801 0 : if (!SWIG_IsOK(res1)) {
35802 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_iversion_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35803 : }
35804 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35805 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
35806 0 : if (!SWIG_IsOK(res2)) {
35807 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_iversion_set" "', argument " "2"" of type '" "char *""'");
35808 : }
35809 0 : arg2 = (char *)(buf2);
35810 : {
35811 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35812 0 : if (arg1->iversion) free((char*)arg1->iversion);
35813 0 : if (arg2) {
35814 0 : size_t size = strlen((const char *)(arg2)) + 1;
35815 0 : arg1->iversion = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
35816 : } else {
35817 0 : arg1->iversion = 0;
35818 : }
35819 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35820 : }
35821 0 : resultobj = SWIG_Py_Void();
35822 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35823 : return resultobj;
35824 : fail:
35825 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
35826 : return NULL;
35827 : }
35828 :
35829 :
35830 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_iversion_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35831 0 : PyObject *resultobj = 0;
35832 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35833 0 : void *argp1 = 0 ;
35834 0 : int res1 = 0 ;
35835 0 : PyObject * obj0 = 0 ;
35836 0 : char *result = 0 ;
35837 :
35838 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_iversion_get",&obj0)) SWIG_fail;
35839 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35840 0 : if (!SWIG_IsOK(res1)) {
35841 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_iversion_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35842 : }
35843 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35844 : {
35845 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35846 0 : result = (char *) ((arg1)->iversion);
35847 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35848 : }
35849 0 : resultobj = SWIG_FromCharPtr((const char *)result);
35850 0 : return resultobj;
35851 : fail:
35852 : return NULL;
35853 : }
35854 :
35855 :
35856 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_created_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35857 0 : PyObject *resultobj = 0;
35858 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35859 : unsigned long arg2 ;
35860 0 : void *argp1 = 0 ;
35861 0 : int res1 = 0 ;
35862 : unsigned long val2 ;
35863 0 : int ecode2 = 0 ;
35864 0 : PyObject * obj0 = 0 ;
35865 0 : PyObject * obj1 = 0 ;
35866 :
35867 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_created_set",&obj0,&obj1)) SWIG_fail;
35868 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35869 0 : if (!SWIG_IsOK(res1)) {
35870 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_created_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35871 : }
35872 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35873 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
35874 0 : if (!SWIG_IsOK(ecode2)) {
35875 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_created_set" "', argument " "2"" of type '" "unsigned long""'");
35876 : }
35877 0 : arg2 = (unsigned long)(val2);
35878 : {
35879 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35880 0 : if (arg1) (arg1)->created = arg2;
35881 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35882 : }
35883 0 : resultobj = SWIG_Py_Void();
35884 0 : return resultobj;
35885 : fail:
35886 : return NULL;
35887 : }
35888 :
35889 :
35890 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_created_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35891 0 : PyObject *resultobj = 0;
35892 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35893 0 : void *argp1 = 0 ;
35894 0 : int res1 = 0 ;
35895 0 : PyObject * obj0 = 0 ;
35896 : unsigned long result;
35897 :
35898 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_created_get",&obj0)) SWIG_fail;
35899 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35900 0 : if (!SWIG_IsOK(res1)) {
35901 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_created_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35902 : }
35903 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35904 : {
35905 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35906 0 : result = (unsigned long) ((arg1)->created);
35907 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35908 : }
35909 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35910 0 : return resultobj;
35911 : fail:
35912 : return NULL;
35913 : }
35914 :
35915 :
35916 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_retrieved_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35917 0 : PyObject *resultobj = 0;
35918 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35919 : unsigned long arg2 ;
35920 0 : void *argp1 = 0 ;
35921 0 : int res1 = 0 ;
35922 : unsigned long val2 ;
35923 0 : int ecode2 = 0 ;
35924 0 : PyObject * obj0 = 0 ;
35925 0 : PyObject * obj1 = 0 ;
35926 :
35927 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_retrieved_set",&obj0,&obj1)) SWIG_fail;
35928 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35929 0 : if (!SWIG_IsOK(res1)) {
35930 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_retrieved_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35931 : }
35932 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35933 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
35934 0 : if (!SWIG_IsOK(ecode2)) {
35935 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_retrieved_set" "', argument " "2"" of type '" "unsigned long""'");
35936 : }
35937 0 : arg2 = (unsigned long)(val2);
35938 : {
35939 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35940 0 : if (arg1) (arg1)->retrieved = arg2;
35941 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35942 : }
35943 0 : resultobj = SWIG_Py_Void();
35944 0 : return resultobj;
35945 : fail:
35946 : return NULL;
35947 : }
35948 :
35949 :
35950 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_retrieved_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35951 0 : PyObject *resultobj = 0;
35952 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35953 0 : void *argp1 = 0 ;
35954 0 : int res1 = 0 ;
35955 0 : PyObject * obj0 = 0 ;
35956 : unsigned long result;
35957 :
35958 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_retrieved_get",&obj0)) SWIG_fail;
35959 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35960 0 : if (!SWIG_IsOK(res1)) {
35961 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_retrieved_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35962 : }
35963 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35964 : {
35965 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
35966 0 : result = (unsigned long) ((arg1)->retrieved);
35967 0 : SWIG_PYTHON_THREAD_END_ALLOW;
35968 : }
35969 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35970 0 : return resultobj;
35971 : fail:
35972 : return NULL;
35973 : }
35974 :
35975 :
35976 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_warning_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35977 0 : PyObject *resultobj = 0;
35978 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
35979 : unsigned int arg2 ;
35980 0 : void *argp1 = 0 ;
35981 0 : int res1 = 0 ;
35982 : unsigned int val2 ;
35983 0 : int ecode2 = 0 ;
35984 0 : PyObject * obj0 = 0 ;
35985 0 : PyObject * obj1 = 0 ;
35986 :
35987 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_warning_set",&obj0,&obj1)) SWIG_fail;
35988 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
35989 0 : if (!SWIG_IsOK(res1)) {
35990 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_warning_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
35991 : }
35992 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
35993 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
35994 0 : if (!SWIG_IsOK(ecode2)) {
35995 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_warning_set" "', argument " "2"" of type '" "unsigned int""'");
35996 : }
35997 0 : arg2 = (unsigned int)(val2);
35998 : {
35999 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36000 0 : if (arg1) (arg1)->warning = arg2;
36001 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36002 : }
36003 0 : resultobj = SWIG_Py_Void();
36004 0 : return resultobj;
36005 : fail:
36006 : return NULL;
36007 : }
36008 :
36009 :
36010 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_warning_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36011 0 : PyObject *resultobj = 0;
36012 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36013 0 : void *argp1 = 0 ;
36014 0 : int res1 = 0 ;
36015 0 : PyObject * obj0 = 0 ;
36016 : unsigned int result;
36017 :
36018 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_warning_get",&obj0)) SWIG_fail;
36019 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36020 0 : if (!SWIG_IsOK(res1)) {
36021 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_warning_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36022 : }
36023 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36024 : {
36025 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36026 0 : result = (unsigned int) ((arg1)->warning);
36027 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36028 : }
36029 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36030 0 : return resultobj;
36031 : fail:
36032 : return NULL;
36033 : }
36034 :
36035 :
36036 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_update_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36037 0 : PyObject *resultobj = 0;
36038 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36039 : unsigned int arg2 ;
36040 0 : void *argp1 = 0 ;
36041 0 : int res1 = 0 ;
36042 : unsigned int val2 ;
36043 0 : int ecode2 = 0 ;
36044 0 : PyObject * obj0 = 0 ;
36045 0 : PyObject * obj1 = 0 ;
36046 :
36047 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_update_set",&obj0,&obj1)) SWIG_fail;
36048 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36049 0 : if (!SWIG_IsOK(res1)) {
36050 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_update_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36051 : }
36052 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36053 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36054 0 : if (!SWIG_IsOK(ecode2)) {
36055 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_update_set" "', argument " "2"" of type '" "unsigned int""'");
36056 : }
36057 0 : arg2 = (unsigned int)(val2);
36058 : {
36059 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36060 0 : if (arg1) (arg1)->update = arg2;
36061 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36062 : }
36063 0 : resultobj = SWIG_Py_Void();
36064 0 : return resultobj;
36065 : fail:
36066 : return NULL;
36067 : }
36068 :
36069 :
36070 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_update_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36071 0 : PyObject *resultobj = 0;
36072 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36073 0 : void *argp1 = 0 ;
36074 0 : int res1 = 0 ;
36075 0 : PyObject * obj0 = 0 ;
36076 : unsigned int result;
36077 :
36078 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_update_get",&obj0)) SWIG_fail;
36079 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36080 0 : if (!SWIG_IsOK(res1)) {
36081 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_update_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36082 : }
36083 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36084 : {
36085 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36086 0 : result = (unsigned int) ((arg1)->update);
36087 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36088 : }
36089 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36090 0 : return resultobj;
36091 : fail:
36092 : return NULL;
36093 : }
36094 :
36095 :
36096 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_urgent_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36097 0 : PyObject *resultobj = 0;
36098 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36099 : unsigned int arg2 ;
36100 0 : void *argp1 = 0 ;
36101 0 : int res1 = 0 ;
36102 : unsigned int val2 ;
36103 0 : int ecode2 = 0 ;
36104 0 : PyObject * obj0 = 0 ;
36105 0 : PyObject * obj1 = 0 ;
36106 :
36107 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_urgent_set",&obj0,&obj1)) SWIG_fail;
36108 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36109 0 : if (!SWIG_IsOK(res1)) {
36110 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_urgent_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36111 : }
36112 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36113 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36114 0 : if (!SWIG_IsOK(ecode2)) {
36115 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_urgent_set" "', argument " "2"" of type '" "unsigned int""'");
36116 : }
36117 0 : arg2 = (unsigned int)(val2);
36118 : {
36119 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36120 0 : if (arg1) (arg1)->urgent = arg2;
36121 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36122 : }
36123 0 : resultobj = SWIG_Py_Void();
36124 0 : return resultobj;
36125 : fail:
36126 : return NULL;
36127 : }
36128 :
36129 :
36130 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_urgent_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36131 0 : PyObject *resultobj = 0;
36132 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36133 0 : void *argp1 = 0 ;
36134 0 : int res1 = 0 ;
36135 0 : PyObject * obj0 = 0 ;
36136 : unsigned int result;
36137 :
36138 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_urgent_get",&obj0)) SWIG_fail;
36139 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36140 0 : if (!SWIG_IsOK(res1)) {
36141 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_urgent_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36142 : }
36143 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36144 : {
36145 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36146 0 : result = (unsigned int) ((arg1)->urgent);
36147 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36148 : }
36149 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36150 0 : return resultobj;
36151 : fail:
36152 : return NULL;
36153 : }
36154 :
36155 :
36156 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_noinfo_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36157 0 : PyObject *resultobj = 0;
36158 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36159 : unsigned int arg2 ;
36160 0 : void *argp1 = 0 ;
36161 0 : int res1 = 0 ;
36162 : unsigned int val2 ;
36163 0 : int ecode2 = 0 ;
36164 0 : PyObject * obj0 = 0 ;
36165 0 : PyObject * obj1 = 0 ;
36166 :
36167 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_noinfo_set",&obj0,&obj1)) SWIG_fail;
36168 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36169 0 : if (!SWIG_IsOK(res1)) {
36170 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_noinfo_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36171 : }
36172 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36173 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36174 0 : if (!SWIG_IsOK(ecode2)) {
36175 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_noinfo_set" "', argument " "2"" of type '" "unsigned int""'");
36176 : }
36177 0 : arg2 = (unsigned int)(val2);
36178 : {
36179 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36180 0 : if (arg1) (arg1)->noinfo = arg2;
36181 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36182 : }
36183 0 : resultobj = SWIG_Py_Void();
36184 0 : return resultobj;
36185 : fail:
36186 : return NULL;
36187 : }
36188 :
36189 :
36190 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_noinfo_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36191 0 : PyObject *resultobj = 0;
36192 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36193 0 : void *argp1 = 0 ;
36194 0 : int res1 = 0 ;
36195 0 : PyObject * obj0 = 0 ;
36196 : unsigned int result;
36197 :
36198 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_noinfo_get",&obj0)) SWIG_fail;
36199 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36200 0 : if (!SWIG_IsOK(res1)) {
36201 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_noinfo_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36202 : }
36203 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36204 : {
36205 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36206 0 : result = (unsigned int) ((arg1)->noinfo);
36207 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36208 : }
36209 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36210 0 : return resultobj;
36211 : fail:
36212 : return NULL;
36213 : }
36214 :
36215 :
36216 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_unknown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36217 0 : PyObject *resultobj = 0;
36218 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36219 : unsigned int arg2 ;
36220 0 : void *argp1 = 0 ;
36221 0 : int res1 = 0 ;
36222 : unsigned int val2 ;
36223 0 : int ecode2 = 0 ;
36224 0 : PyObject * obj0 = 0 ;
36225 0 : PyObject * obj1 = 0 ;
36226 :
36227 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_unknown_set",&obj0,&obj1)) SWIG_fail;
36228 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36229 0 : if (!SWIG_IsOK(res1)) {
36230 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_unknown_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36231 : }
36232 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36233 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36234 0 : if (!SWIG_IsOK(ecode2)) {
36235 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_unknown_set" "', argument " "2"" of type '" "unsigned int""'");
36236 : }
36237 0 : arg2 = (unsigned int)(val2);
36238 : {
36239 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36240 0 : if (arg1) (arg1)->unknown = arg2;
36241 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36242 : }
36243 0 : resultobj = SWIG_Py_Void();
36244 0 : return resultobj;
36245 : fail:
36246 : return NULL;
36247 : }
36248 :
36249 :
36250 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_unknown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36251 0 : PyObject *resultobj = 0;
36252 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36253 0 : void *argp1 = 0 ;
36254 0 : int res1 = 0 ;
36255 0 : PyObject * obj0 = 0 ;
36256 : unsigned int result;
36257 :
36258 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_unknown_get",&obj0)) SWIG_fail;
36259 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36260 0 : if (!SWIG_IsOK(res1)) {
36261 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_unknown_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36262 : }
36263 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36264 : {
36265 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36266 0 : result = (unsigned int) ((arg1)->unknown);
36267 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36268 : }
36269 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36270 0 : return resultobj;
36271 : fail:
36272 : return NULL;
36273 : }
36274 :
36275 :
36276 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_tooold_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36277 0 : PyObject *resultobj = 0;
36278 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36279 : unsigned int arg2 ;
36280 0 : void *argp1 = 0 ;
36281 0 : int res1 = 0 ;
36282 : unsigned int val2 ;
36283 0 : int ecode2 = 0 ;
36284 0 : PyObject * obj0 = 0 ;
36285 0 : PyObject * obj1 = 0 ;
36286 :
36287 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_tooold_set",&obj0,&obj1)) SWIG_fail;
36288 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36289 0 : if (!SWIG_IsOK(res1)) {
36290 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_tooold_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36291 : }
36292 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36293 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36294 0 : if (!SWIG_IsOK(ecode2)) {
36295 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_tooold_set" "', argument " "2"" of type '" "unsigned int""'");
36296 : }
36297 0 : arg2 = (unsigned int)(val2);
36298 : {
36299 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36300 0 : if (arg1) (arg1)->tooold = arg2;
36301 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36302 : }
36303 0 : resultobj = SWIG_Py_Void();
36304 0 : return resultobj;
36305 : fail:
36306 : return NULL;
36307 : }
36308 :
36309 :
36310 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_tooold_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36311 0 : PyObject *resultobj = 0;
36312 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36313 0 : void *argp1 = 0 ;
36314 0 : int res1 = 0 ;
36315 0 : PyObject * obj0 = 0 ;
36316 : unsigned int result;
36317 :
36318 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_tooold_get",&obj0)) SWIG_fail;
36319 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36320 0 : if (!SWIG_IsOK(res1)) {
36321 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_tooold_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36322 : }
36323 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36324 : {
36325 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36326 0 : result = (unsigned int) ((arg1)->tooold);
36327 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36328 : }
36329 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36330 0 : return resultobj;
36331 : fail:
36332 : return NULL;
36333 : }
36334 :
36335 :
36336 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_error_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36337 0 : PyObject *resultobj = 0;
36338 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36339 : unsigned int arg2 ;
36340 0 : void *argp1 = 0 ;
36341 0 : int res1 = 0 ;
36342 : unsigned int val2 ;
36343 0 : int ecode2 = 0 ;
36344 0 : PyObject * obj0 = 0 ;
36345 0 : PyObject * obj1 = 0 ;
36346 :
36347 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_error_set",&obj0,&obj1)) SWIG_fail;
36348 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36349 0 : if (!SWIG_IsOK(res1)) {
36350 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_error_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36351 : }
36352 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36353 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36354 0 : if (!SWIG_IsOK(ecode2)) {
36355 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_error_set" "', argument " "2"" of type '" "unsigned int""'");
36356 : }
36357 0 : arg2 = (unsigned int)(val2);
36358 : {
36359 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36360 0 : if (arg1) (arg1)->error = arg2;
36361 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36362 : }
36363 0 : resultobj = SWIG_Py_Void();
36364 0 : return resultobj;
36365 : fail:
36366 : return NULL;
36367 : }
36368 :
36369 :
36370 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_error_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36371 0 : PyObject *resultobj = 0;
36372 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36373 0 : void *argp1 = 0 ;
36374 0 : int res1 = 0 ;
36375 0 : PyObject * obj0 = 0 ;
36376 : unsigned int result;
36377 :
36378 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_error_get",&obj0)) SWIG_fail;
36379 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36380 0 : if (!SWIG_IsOK(res1)) {
36381 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_error_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36382 : }
36383 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36384 : {
36385 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36386 0 : result = (unsigned int) ((arg1)->error);
36387 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36388 : }
36389 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36390 0 : return resultobj;
36391 : fail:
36392 : return NULL;
36393 : }
36394 :
36395 :
36396 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result__reserved_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36397 0 : PyObject *resultobj = 0;
36398 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36399 : unsigned int arg2 ;
36400 0 : void *argp1 = 0 ;
36401 0 : int res1 = 0 ;
36402 : unsigned int val2 ;
36403 0 : int ecode2 = 0 ;
36404 0 : PyObject * obj0 = 0 ;
36405 0 : PyObject * obj1 = 0 ;
36406 :
36407 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result__reserved_set",&obj0,&obj1)) SWIG_fail;
36408 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36409 0 : if (!SWIG_IsOK(res1)) {
36410 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result__reserved_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36411 : }
36412 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36413 0 : ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
36414 0 : if (!SWIG_IsOK(ecode2)) {
36415 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result__reserved_set" "', argument " "2"" of type '" "unsigned int""'");
36416 : }
36417 0 : arg2 = (unsigned int)(val2);
36418 : {
36419 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36420 0 : if (arg1) (arg1)->_reserved = arg2;
36421 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36422 : }
36423 0 : resultobj = SWIG_Py_Void();
36424 0 : return resultobj;
36425 : fail:
36426 : return NULL;
36427 : }
36428 :
36429 :
36430 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result__reserved_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36431 0 : PyObject *resultobj = 0;
36432 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36433 0 : void *argp1 = 0 ;
36434 0 : int res1 = 0 ;
36435 0 : PyObject * obj0 = 0 ;
36436 : unsigned int result;
36437 :
36438 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result__reserved_get",&obj0)) SWIG_fail;
36439 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36440 0 : if (!SWIG_IsOK(res1)) {
36441 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result__reserved_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36442 : }
36443 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36444 : {
36445 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36446 0 : result = (unsigned int) ((arg1)->_reserved);
36447 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36448 : }
36449 0 : resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
36450 0 : return resultobj;
36451 : fail:
36452 : return NULL;
36453 : }
36454 :
36455 :
36456 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_version_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36457 0 : PyObject *resultobj = 0;
36458 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36459 0 : char *arg2 = (char *) 0 ;
36460 0 : void *argp1 = 0 ;
36461 0 : int res1 = 0 ;
36462 : int res2 ;
36463 0 : char *buf2 = 0 ;
36464 0 : int alloc2 = 0 ;
36465 0 : PyObject * obj0 = 0 ;
36466 0 : PyObject * obj1 = 0 ;
36467 :
36468 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_version_set",&obj0,&obj1)) SWIG_fail;
36469 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36470 0 : if (!SWIG_IsOK(res1)) {
36471 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_version_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36472 : }
36473 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36474 0 : res2 = SWIG_AsCharPtrAndSize(obj1, &buf2, NULL, &alloc2);
36475 0 : if (!SWIG_IsOK(res2)) {
36476 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "_gpgme_op_query_swdb_result_version_set" "', argument " "2"" of type '" "char *""'");
36477 : }
36478 0 : arg2 = (char *)(buf2);
36479 : {
36480 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36481 0 : if (arg1->version) free((char*)arg1->version);
36482 0 : if (arg2) {
36483 0 : size_t size = strlen((const char *)(arg2)) + 1;
36484 0 : arg1->version = (char *)(char *)memcpy((char *)malloc((size)*sizeof(char)), (const char *)(arg2), sizeof(char)*(size));
36485 : } else {
36486 0 : arg1->version = 0;
36487 : }
36488 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36489 : }
36490 0 : resultobj = SWIG_Py_Void();
36491 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36492 : return resultobj;
36493 : fail:
36494 0 : if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
36495 : return NULL;
36496 : }
36497 :
36498 :
36499 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_version_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36500 0 : PyObject *resultobj = 0;
36501 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36502 0 : void *argp1 = 0 ;
36503 0 : int res1 = 0 ;
36504 0 : PyObject * obj0 = 0 ;
36505 0 : char *result = 0 ;
36506 :
36507 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_version_get",&obj0)) SWIG_fail;
36508 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36509 0 : if (!SWIG_IsOK(res1)) {
36510 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_version_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36511 : }
36512 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36513 : {
36514 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36515 0 : result = (char *) ((arg1)->version);
36516 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36517 : }
36518 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36519 0 : return resultobj;
36520 : fail:
36521 : return NULL;
36522 : }
36523 :
36524 :
36525 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_reldate_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36526 0 : PyObject *resultobj = 0;
36527 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36528 : unsigned long arg2 ;
36529 0 : void *argp1 = 0 ;
36530 0 : int res1 = 0 ;
36531 : unsigned long val2 ;
36532 0 : int ecode2 = 0 ;
36533 0 : PyObject * obj0 = 0 ;
36534 0 : PyObject * obj1 = 0 ;
36535 :
36536 0 : if (!PyArg_ParseTuple(args,(char *)"OO:_gpgme_op_query_swdb_result_reldate_set",&obj0,&obj1)) SWIG_fail;
36537 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36538 0 : if (!SWIG_IsOK(res1)) {
36539 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_reldate_set" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36540 : }
36541 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36542 0 : ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
36543 0 : if (!SWIG_IsOK(ecode2)) {
36544 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_gpgme_op_query_swdb_result_reldate_set" "', argument " "2"" of type '" "unsigned long""'");
36545 : }
36546 0 : arg2 = (unsigned long)(val2);
36547 : {
36548 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36549 0 : if (arg1) (arg1)->reldate = arg2;
36550 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36551 : }
36552 0 : resultobj = SWIG_Py_Void();
36553 0 : return resultobj;
36554 : fail:
36555 : return NULL;
36556 : }
36557 :
36558 :
36559 0 : SWIGINTERN PyObject *_wrap__gpgme_op_query_swdb_result_reldate_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36560 0 : PyObject *resultobj = 0;
36561 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36562 0 : void *argp1 = 0 ;
36563 0 : int res1 = 0 ;
36564 0 : PyObject * obj0 = 0 ;
36565 : unsigned long result;
36566 :
36567 0 : if (!PyArg_ParseTuple(args,(char *)"O:_gpgme_op_query_swdb_result_reldate_get",&obj0)) SWIG_fail;
36568 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36569 0 : if (!SWIG_IsOK(res1)) {
36570 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "_gpgme_op_query_swdb_result_reldate_get" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36571 : }
36572 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36573 : {
36574 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36575 0 : result = (unsigned long) ((arg1)->reldate);
36576 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36577 : }
36578 0 : resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
36579 0 : return resultobj;
36580 : fail:
36581 : return NULL;
36582 : }
36583 :
36584 :
36585 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36586 0 : PyObject *resultobj = 0;
36587 0 : struct _gpgme_op_query_swdb_result *result = 0 ;
36588 :
36589 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_query_swdb_result")) SWIG_fail;
36590 : {
36591 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36592 0 : result = (struct _gpgme_op_query_swdb_result *)calloc(1, sizeof(struct _gpgme_op_query_swdb_result));
36593 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36594 : }
36595 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_POINTER_NEW | 0 );
36596 0 : return resultobj;
36597 : fail:
36598 : return NULL;
36599 : }
36600 :
36601 :
36602 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36603 0 : PyObject *resultobj = 0;
36604 0 : struct _gpgme_op_query_swdb_result *arg1 = (struct _gpgme_op_query_swdb_result *) 0 ;
36605 0 : void *argp1 = 0 ;
36606 0 : int res1 = 0 ;
36607 0 : PyObject * obj0 = 0 ;
36608 :
36609 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_query_swdb_result",&obj0)) SWIG_fail;
36610 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_POINTER_DISOWN | 0 );
36611 0 : if (!SWIG_IsOK(res1)) {
36612 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_query_swdb_result" "', argument " "1"" of type '" "struct _gpgme_op_query_swdb_result *""'");
36613 : }
36614 0 : arg1 = (struct _gpgme_op_query_swdb_result *)(argp1);
36615 : {
36616 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36617 0 : free((char *) arg1);
36618 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36619 : }
36620 0 : resultobj = SWIG_Py_Void();
36621 0 : return resultobj;
36622 : fail:
36623 : return NULL;
36624 : }
36625 :
36626 :
36627 27 : SWIGINTERN PyObject *_gpgme_op_query_swdb_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36628 : PyObject *obj;
36629 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
36630 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_query_swdb_result, SWIG_NewClientData(obj));
36631 27 : return SWIG_Py_Void();
36632 : }
36633 :
36634 0 : SWIGINTERN PyObject *_wrap_gpgme_op_query_swdb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36635 0 : PyObject *resultobj = 0;
36636 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36637 0 : char *arg2 = (char *) 0 ;
36638 0 : char *arg3 = (char *) 0 ;
36639 : unsigned int arg4 ;
36640 0 : void *argp1 = 0 ;
36641 0 : int res1 = 0 ;
36642 0 : PyObject *encodedInput2 = NULL ;
36643 0 : PyObject *encodedInput3 = NULL ;
36644 : unsigned int val4 ;
36645 0 : int ecode4 = 0 ;
36646 0 : PyObject * obj0 = 0 ;
36647 0 : PyObject * obj1 = 0 ;
36648 0 : PyObject * obj2 = 0 ;
36649 0 : PyObject * obj3 = 0 ;
36650 : gpgme_error_t result;
36651 :
36652 0 : if (!PyArg_ParseTuple(args,(char *)"OOOO:gpgme_op_query_swdb",&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36653 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36654 0 : if (!SWIG_IsOK(res1)) {
36655 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_query_swdb" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36656 : }
36657 0 : arg1 = (gpgme_ctx_t)(argp1);
36658 : {
36659 0 : if (obj1 == Py_None)
36660 : arg2 = NULL;
36661 0 : else if (PyUnicode_Check(obj1))
36662 : {
36663 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
36664 0 : if (encodedInput2 == NULL)
36665 : return NULL;
36666 0 : arg2 = PyBytes_AsString(encodedInput2);
36667 : }
36668 0 : else if (PyBytes_Check(obj1))
36669 0 : arg2 = PyBytes_AsString(obj1);
36670 : else {
36671 0 : PyErr_Format(PyExc_TypeError,
36672 : "arg %d: expected str, bytes, or None, got %s",
36673 : 2, obj1->ob_type->tp_name);
36674 0 : return NULL;
36675 : }
36676 : }
36677 : {
36678 0 : if (obj2 == Py_None)
36679 : arg3 = NULL;
36680 0 : else if (PyUnicode_Check(obj2))
36681 : {
36682 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
36683 0 : if (encodedInput3 == NULL)
36684 : return NULL;
36685 0 : arg3 = PyBytes_AsString(encodedInput3);
36686 : }
36687 0 : else if (PyBytes_Check(obj2))
36688 0 : arg3 = PyBytes_AsString(obj2);
36689 : else {
36690 0 : PyErr_Format(PyExc_TypeError,
36691 : "arg %d: expected str, bytes, or None, got %s",
36692 : 3, obj2->ob_type->tp_name);
36693 0 : return NULL;
36694 : }
36695 : }
36696 0 : ecode4 = SWIG_AsVal_unsigned_SS_int(obj3, &val4);
36697 0 : if (!SWIG_IsOK(ecode4)) {
36698 0 : SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "gpgme_op_query_swdb" "', argument " "4"" of type '" "unsigned int""'");
36699 : }
36700 0 : arg4 = (unsigned int)(val4);
36701 : {
36702 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36703 0 : result = gpgme_op_query_swdb(arg1,(char const *)arg2,(char const *)arg3,arg4);
36704 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36705 : }
36706 : {
36707 0 : resultobj = PyLong_FromLong(result);
36708 : }
36709 : {
36710 0 : Py_XDECREF(encodedInput2);
36711 : }
36712 : {
36713 0 : Py_XDECREF(encodedInput3);
36714 : }
36715 : return resultobj;
36716 : fail:
36717 : {
36718 0 : Py_XDECREF(encodedInput2);
36719 : }
36720 : {
36721 0 : Py_XDECREF(encodedInput3);
36722 : }
36723 : return NULL;
36724 : }
36725 :
36726 :
36727 0 : SWIGINTERN PyObject *_wrap_gpgme_op_query_swdb_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36728 0 : PyObject *resultobj = 0;
36729 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
36730 0 : void *argp1 = 0 ;
36731 0 : int res1 = 0 ;
36732 0 : PyObject * obj0 = 0 ;
36733 : gpgme_query_swdb_result_t result;
36734 :
36735 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_op_query_swdb_result",&obj0)) SWIG_fail;
36736 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
36737 0 : if (!SWIG_IsOK(res1)) {
36738 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_op_query_swdb_result" "', argument " "1"" of type '" "gpgme_ctx_t""'");
36739 : }
36740 0 : arg1 = (gpgme_ctx_t)(argp1);
36741 : {
36742 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36743 0 : result = (gpgme_query_swdb_result_t)gpgme_op_query_swdb_result(arg1);
36744 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36745 : }
36746 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_query_swdb_result, 0 | 0 );
36747 0 : return resultobj;
36748 : fail:
36749 : return NULL;
36750 : }
36751 :
36752 :
36753 0 : SWIGINTERN PyObject *_wrap_gpgme_set_global_flag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36754 0 : PyObject *resultobj = 0;
36755 0 : char *arg1 = (char *) 0 ;
36756 0 : char *arg2 = (char *) 0 ;
36757 0 : PyObject *encodedInput1 = NULL ;
36758 0 : PyObject *encodedInput2 = NULL ;
36759 0 : PyObject * obj0 = 0 ;
36760 0 : PyObject * obj1 = 0 ;
36761 : int result;
36762 :
36763 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_set_global_flag",&obj0,&obj1)) SWIG_fail;
36764 : {
36765 0 : if (obj0 == Py_None)
36766 : arg1 = NULL;
36767 0 : else if (PyUnicode_Check(obj0))
36768 : {
36769 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
36770 0 : if (encodedInput1 == NULL)
36771 : return NULL;
36772 0 : arg1 = PyBytes_AsString(encodedInput1);
36773 : }
36774 0 : else if (PyBytes_Check(obj0))
36775 0 : arg1 = PyBytes_AsString(obj0);
36776 : else {
36777 0 : PyErr_Format(PyExc_TypeError,
36778 : "arg %d: expected str, bytes, or None, got %s",
36779 : 1, obj0->ob_type->tp_name);
36780 0 : return NULL;
36781 : }
36782 : }
36783 : {
36784 0 : if (obj1 == Py_None)
36785 : arg2 = NULL;
36786 0 : else if (PyUnicode_Check(obj1))
36787 : {
36788 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
36789 0 : if (encodedInput2 == NULL)
36790 : return NULL;
36791 0 : arg2 = PyBytes_AsString(encodedInput2);
36792 : }
36793 0 : else if (PyBytes_Check(obj1))
36794 0 : arg2 = PyBytes_AsString(obj1);
36795 : else {
36796 0 : PyErr_Format(PyExc_TypeError,
36797 : "arg %d: expected str, bytes, or None, got %s",
36798 : 2, obj1->ob_type->tp_name);
36799 0 : return NULL;
36800 : }
36801 : }
36802 : {
36803 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36804 0 : result = (int)gpgme_set_global_flag((char const *)arg1,(char const *)arg2);
36805 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36806 : }
36807 0 : resultobj = SWIG_From_int((int)(result));
36808 : {
36809 0 : Py_XDECREF(encodedInput1);
36810 : }
36811 : {
36812 0 : Py_XDECREF(encodedInput2);
36813 : }
36814 : return resultobj;
36815 : fail:
36816 : {
36817 : Py_XDECREF(encodedInput1);
36818 : }
36819 : {
36820 : Py_XDECREF(encodedInput2);
36821 : }
36822 : return NULL;
36823 : }
36824 :
36825 :
36826 27 : SWIGINTERN PyObject *_wrap_gpgme_check_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36827 27 : PyObject *resultobj = 0;
36828 27 : char *arg1 = (char *) 0 ;
36829 27 : PyObject *encodedInput1 = NULL ;
36830 27 : PyObject * obj0 = 0 ;
36831 27 : char *result = 0 ;
36832 :
36833 27 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_check_version",&obj0)) SWIG_fail;
36834 : {
36835 27 : if (obj0 == Py_None)
36836 : arg1 = NULL;
36837 0 : else if (PyUnicode_Check(obj0))
36838 : {
36839 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
36840 0 : if (encodedInput1 == NULL)
36841 : return NULL;
36842 0 : arg1 = PyBytes_AsString(encodedInput1);
36843 : }
36844 0 : else if (PyBytes_Check(obj0))
36845 0 : arg1 = PyBytes_AsString(obj0);
36846 : else {
36847 0 : PyErr_Format(PyExc_TypeError,
36848 : "arg %d: expected str, bytes, or None, got %s",
36849 : 1, obj0->ob_type->tp_name);
36850 0 : return NULL;
36851 : }
36852 : }
36853 : {
36854 27 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36855 27 : result = (char *)gpgme_check_version((char const *)arg1);
36856 27 : SWIG_PYTHON_THREAD_END_ALLOW;
36857 : }
36858 27 : resultobj = SWIG_FromCharPtr((const char *)result);
36859 : {
36860 27 : Py_XDECREF(encodedInput1);
36861 : }
36862 : return resultobj;
36863 : fail:
36864 : {
36865 : Py_XDECREF(encodedInput1);
36866 : }
36867 : return NULL;
36868 : }
36869 :
36870 :
36871 0 : SWIGINTERN PyObject *_wrap_gpgme_check_version_internal(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36872 0 : PyObject *resultobj = 0;
36873 0 : char *arg1 = (char *) 0 ;
36874 : size_t arg2 ;
36875 0 : PyObject *encodedInput1 = NULL ;
36876 : size_t val2 ;
36877 0 : int ecode2 = 0 ;
36878 0 : PyObject * obj0 = 0 ;
36879 0 : PyObject * obj1 = 0 ;
36880 0 : char *result = 0 ;
36881 :
36882 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_check_version_internal",&obj0,&obj1)) SWIG_fail;
36883 : {
36884 0 : if (obj0 == Py_None)
36885 : arg1 = NULL;
36886 0 : else if (PyUnicode_Check(obj0))
36887 : {
36888 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
36889 0 : if (encodedInput1 == NULL)
36890 : return NULL;
36891 0 : arg1 = PyBytes_AsString(encodedInput1);
36892 : }
36893 0 : else if (PyBytes_Check(obj0))
36894 0 : arg1 = PyBytes_AsString(obj0);
36895 : else {
36896 0 : PyErr_Format(PyExc_TypeError,
36897 : "arg %d: expected str, bytes, or None, got %s",
36898 : 1, obj0->ob_type->tp_name);
36899 0 : return NULL;
36900 : }
36901 : }
36902 0 : ecode2 = SWIG_AsVal_size_t(obj1, &val2);
36903 0 : if (!SWIG_IsOK(ecode2)) {
36904 0 : SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "gpgme_check_version_internal" "', argument " "2"" of type '" "size_t""'");
36905 : }
36906 0 : arg2 = (size_t)(val2);
36907 : {
36908 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36909 0 : result = (char *)gpgme_check_version_internal((char const *)arg1,arg2);
36910 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36911 : }
36912 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36913 : {
36914 0 : Py_XDECREF(encodedInput1);
36915 : }
36916 : return resultobj;
36917 : fail:
36918 : {
36919 0 : Py_XDECREF(encodedInput1);
36920 : }
36921 : return NULL;
36922 : }
36923 :
36924 :
36925 0 : SWIGINTERN PyObject *_wrap_gpgme_get_dirinfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36926 0 : PyObject *resultobj = 0;
36927 0 : char *arg1 = (char *) 0 ;
36928 0 : PyObject *encodedInput1 = NULL ;
36929 0 : PyObject * obj0 = 0 ;
36930 0 : char *result = 0 ;
36931 :
36932 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_dirinfo",&obj0)) SWIG_fail;
36933 : {
36934 0 : if (obj0 == Py_None)
36935 : arg1 = NULL;
36936 0 : else if (PyUnicode_Check(obj0))
36937 : {
36938 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
36939 0 : if (encodedInput1 == NULL)
36940 : return NULL;
36941 0 : arg1 = PyBytes_AsString(encodedInput1);
36942 : }
36943 0 : else if (PyBytes_Check(obj0))
36944 0 : arg1 = PyBytes_AsString(obj0);
36945 : else {
36946 0 : PyErr_Format(PyExc_TypeError,
36947 : "arg %d: expected str, bytes, or None, got %s",
36948 : 1, obj0->ob_type->tp_name);
36949 0 : return NULL;
36950 : }
36951 : }
36952 : {
36953 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36954 0 : result = (char *)gpgme_get_dirinfo((char const *)arg1);
36955 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36956 : }
36957 0 : resultobj = SWIG_FromCharPtr((const char *)result);
36958 : {
36959 0 : Py_XDECREF(encodedInput1);
36960 : }
36961 : return resultobj;
36962 : fail:
36963 : {
36964 : Py_XDECREF(encodedInput1);
36965 : }
36966 : return NULL;
36967 : }
36968 :
36969 :
36970 0 : SWIGINTERN PyObject *_wrap_gpgme_get_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36971 0 : PyObject *resultobj = 0;
36972 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
36973 0 : void *argp1 = 0 ;
36974 0 : int res1 = 0 ;
36975 0 : PyObject * obj0 = 0 ;
36976 : gpgme_error_t result;
36977 :
36978 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_get_engine_info",&obj0)) SWIG_fail;
36979 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
36980 0 : if (!SWIG_IsOK(res1)) {
36981 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_get_engine_info" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
36982 : }
36983 0 : arg1 = (gpgme_engine_info_t *)(argp1);
36984 : {
36985 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
36986 0 : result = gpgme_get_engine_info(arg1);
36987 0 : SWIG_PYTHON_THREAD_END_ALLOW;
36988 : }
36989 : {
36990 0 : resultobj = PyLong_FromLong(result);
36991 : }
36992 0 : return resultobj;
36993 : fail:
36994 : return NULL;
36995 : }
36996 :
36997 :
36998 0 : SWIGINTERN PyObject *_wrap_gpgme_set_engine_info(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36999 0 : PyObject *resultobj = 0;
37000 : gpgme_protocol_t arg1 ;
37001 0 : char *arg2 = (char *) 0 ;
37002 0 : char *arg3 = (char *) 0 ;
37003 : int val1 ;
37004 0 : int ecode1 = 0 ;
37005 0 : PyObject *encodedInput2 = NULL ;
37006 0 : PyObject *encodedInput3 = NULL ;
37007 0 : PyObject * obj0 = 0 ;
37008 0 : PyObject * obj1 = 0 ;
37009 0 : PyObject * obj2 = 0 ;
37010 : gpgme_error_t result;
37011 :
37012 0 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpgme_set_engine_info",&obj0,&obj1,&obj2)) SWIG_fail;
37013 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
37014 0 : if (!SWIG_IsOK(ecode1)) {
37015 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_set_engine_info" "', argument " "1"" of type '" "gpgme_protocol_t""'");
37016 : }
37017 0 : arg1 = (gpgme_protocol_t)(val1);
37018 : {
37019 0 : if (obj1 == Py_None)
37020 : arg2 = NULL;
37021 0 : else if (PyUnicode_Check(obj1))
37022 : {
37023 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
37024 0 : if (encodedInput2 == NULL)
37025 : return NULL;
37026 0 : arg2 = PyBytes_AsString(encodedInput2);
37027 : }
37028 0 : else if (PyBytes_Check(obj1))
37029 0 : arg2 = PyBytes_AsString(obj1);
37030 : else {
37031 0 : PyErr_Format(PyExc_TypeError,
37032 : "arg %d: expected str, bytes, or None, got %s",
37033 : 2, obj1->ob_type->tp_name);
37034 0 : return NULL;
37035 : }
37036 : }
37037 : {
37038 0 : if (obj2 == Py_None)
37039 : arg3 = NULL;
37040 0 : else if (PyUnicode_Check(obj2))
37041 : {
37042 0 : encodedInput3 = PyUnicode_AsUTF8String(obj2);
37043 0 : if (encodedInput3 == NULL)
37044 : return NULL;
37045 0 : arg3 = PyBytes_AsString(encodedInput3);
37046 : }
37047 0 : else if (PyBytes_Check(obj2))
37048 0 : arg3 = PyBytes_AsString(obj2);
37049 : else {
37050 0 : PyErr_Format(PyExc_TypeError,
37051 : "arg %d: expected str, bytes, or None, got %s",
37052 : 3, obj2->ob_type->tp_name);
37053 0 : return NULL;
37054 : }
37055 : }
37056 : {
37057 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37058 0 : result = gpgme_set_engine_info(arg1,(char const *)arg2,(char const *)arg3);
37059 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37060 : }
37061 : {
37062 0 : resultobj = PyLong_FromLong(result);
37063 : }
37064 : {
37065 0 : Py_XDECREF(encodedInput2);
37066 : }
37067 : {
37068 0 : Py_XDECREF(encodedInput3);
37069 : }
37070 : return resultobj;
37071 : fail:
37072 : {
37073 : Py_XDECREF(encodedInput2);
37074 : }
37075 : {
37076 : Py_XDECREF(encodedInput3);
37077 : }
37078 : return NULL;
37079 : }
37080 :
37081 :
37082 73 : SWIGINTERN PyObject *_wrap_gpgme_engine_check_version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37083 73 : PyObject *resultobj = 0;
37084 : gpgme_protocol_t arg1 ;
37085 : int val1 ;
37086 73 : int ecode1 = 0 ;
37087 73 : PyObject * obj0 = 0 ;
37088 : gpgme_error_t result;
37089 :
37090 73 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_check_version",&obj0)) SWIG_fail;
37091 146 : ecode1 = SWIG_AsVal_int(obj0, &val1);
37092 73 : if (!SWIG_IsOK(ecode1)) {
37093 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_engine_check_version" "', argument " "1"" of type '" "gpgme_protocol_t""'");
37094 : }
37095 73 : arg1 = (gpgme_protocol_t)(val1);
37096 : {
37097 73 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37098 73 : result = gpgme_engine_check_version(arg1);
37099 73 : SWIG_PYTHON_THREAD_END_ALLOW;
37100 : }
37101 : {
37102 73 : resultobj = PyLong_FromLong(result);
37103 : }
37104 73 : return resultobj;
37105 : fail:
37106 : return NULL;
37107 : }
37108 :
37109 :
37110 0 : SWIGINTERN PyObject *_wrap_gpgme_result_ref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37111 0 : PyObject *resultobj = 0;
37112 0 : void *arg1 = (void *) 0 ;
37113 : int res1 ;
37114 0 : PyObject * obj0 = 0 ;
37115 :
37116 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_ref",&obj0)) SWIG_fail;
37117 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
37118 0 : if (!SWIG_IsOK(res1)) {
37119 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_ref" "', argument " "1"" of type '" "void *""'");
37120 : }
37121 : {
37122 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37123 0 : gpgme_result_ref(arg1);
37124 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37125 : }
37126 0 : resultobj = SWIG_Py_Void();
37127 0 : return resultobj;
37128 : fail:
37129 : return NULL;
37130 : }
37131 :
37132 :
37133 0 : SWIGINTERN PyObject *_wrap_gpgme_result_unref(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37134 0 : PyObject *resultobj = 0;
37135 0 : void *arg1 = (void *) 0 ;
37136 : int res1 ;
37137 0 : PyObject * obj0 = 0 ;
37138 :
37139 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_result_unref",&obj0)) SWIG_fail;
37140 0 : res1 = SWIG_ConvertPtr(obj0,SWIG_as_voidptrptr(&arg1), 0, 0);
37141 0 : if (!SWIG_IsOK(res1)) {
37142 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_result_unref" "', argument " "1"" of type '" "void *""'");
37143 : }
37144 : {
37145 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37146 0 : gpgme_result_unref(arg1);
37147 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37148 : }
37149 0 : resultobj = SWIG_Py_Void();
37150 0 : return resultobj;
37151 : fail:
37152 : return NULL;
37153 : }
37154 :
37155 :
37156 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_string(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37157 0 : PyObject *resultobj = 0;
37158 0 : gpgme_subkey_t arg1 = (gpgme_subkey_t) 0 ;
37159 0 : void *argp1 = 0 ;
37160 0 : int res1 = 0 ;
37161 0 : PyObject * obj0 = 0 ;
37162 0 : char *result = 0 ;
37163 :
37164 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_string",&obj0)) SWIG_fail;
37165 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_subkey, 0 | 0 );
37166 0 : if (!SWIG_IsOK(res1)) {
37167 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_pubkey_algo_string" "', argument " "1"" of type '" "gpgme_subkey_t""'");
37168 : }
37169 0 : arg1 = (gpgme_subkey_t)(argp1);
37170 : {
37171 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37172 0 : result = (char *)gpgme_pubkey_algo_string(arg1);
37173 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37174 : }
37175 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37176 0 : gpgme_free(result);
37177 0 : return resultobj;
37178 : fail:
37179 : return NULL;
37180 : }
37181 :
37182 :
37183 0 : SWIGINTERN PyObject *_wrap_gpgme_pubkey_algo_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37184 0 : PyObject *resultobj = 0;
37185 : gpgme_pubkey_algo_t arg1 ;
37186 : int val1 ;
37187 0 : int ecode1 = 0 ;
37188 0 : PyObject * obj0 = 0 ;
37189 0 : char *result = 0 ;
37190 :
37191 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_pubkey_algo_name",&obj0)) SWIG_fail;
37192 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
37193 0 : if (!SWIG_IsOK(ecode1)) {
37194 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_pubkey_algo_name" "', argument " "1"" of type '" "gpgme_pubkey_algo_t""'");
37195 : }
37196 0 : arg1 = (gpgme_pubkey_algo_t)(val1);
37197 : {
37198 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37199 0 : result = (char *)gpgme_pubkey_algo_name(arg1);
37200 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37201 : }
37202 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37203 0 : return resultobj;
37204 : fail:
37205 : return NULL;
37206 : }
37207 :
37208 :
37209 0 : SWIGINTERN PyObject *_wrap_gpgme_hash_algo_name(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37210 0 : PyObject *resultobj = 0;
37211 : gpgme_hash_algo_t arg1 ;
37212 : int val1 ;
37213 0 : int ecode1 = 0 ;
37214 0 : PyObject * obj0 = 0 ;
37215 0 : char *result = 0 ;
37216 :
37217 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_hash_algo_name",&obj0)) SWIG_fail;
37218 0 : ecode1 = SWIG_AsVal_int(obj0, &val1);
37219 0 : if (!SWIG_IsOK(ecode1)) {
37220 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "gpgme_hash_algo_name" "', argument " "1"" of type '" "gpgme_hash_algo_t""'");
37221 : }
37222 0 : arg1 = (gpgme_hash_algo_t)(val1);
37223 : {
37224 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37225 0 : result = (char *)gpgme_hash_algo_name(arg1);
37226 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37227 : }
37228 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37229 0 : return resultobj;
37230 : fail:
37231 : return NULL;
37232 : }
37233 :
37234 :
37235 0 : SWIGINTERN PyObject *_wrap_gpgme_addrspec_from_uid(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37236 0 : PyObject *resultobj = 0;
37237 0 : char *arg1 = (char *) 0 ;
37238 0 : PyObject *encodedInput1 = NULL ;
37239 0 : PyObject * obj0 = 0 ;
37240 0 : char *result = 0 ;
37241 :
37242 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_addrspec_from_uid",&obj0)) SWIG_fail;
37243 : {
37244 0 : if (obj0 == Py_None)
37245 : arg1 = NULL;
37246 0 : else if (PyUnicode_Check(obj0))
37247 : {
37248 0 : encodedInput1 = PyUnicode_AsUTF8String(obj0);
37249 0 : if (encodedInput1 == NULL)
37250 : return NULL;
37251 0 : arg1 = PyBytes_AsString(encodedInput1);
37252 : }
37253 0 : else if (PyBytes_Check(obj0))
37254 0 : arg1 = PyBytes_AsString(obj0);
37255 : else {
37256 0 : PyErr_Format(PyExc_TypeError,
37257 : "arg %d: expected str, bytes, or None, got %s",
37258 : 1, obj0->ob_type->tp_name);
37259 0 : return NULL;
37260 : }
37261 : }
37262 : {
37263 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37264 0 : result = (char *)gpgme_addrspec_from_uid((char const *)arg1);
37265 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37266 : }
37267 0 : resultobj = SWIG_FromCharPtr((const char *)result);
37268 : {
37269 0 : Py_XDECREF(encodedInput1);
37270 : }
37271 0 : gpgme_free(result);
37272 0 : return resultobj;
37273 : fail:
37274 : {
37275 : Py_XDECREF(encodedInput1);
37276 : }
37277 : return NULL;
37278 : }
37279 :
37280 :
37281 0 : SWIGINTERN PyObject *_wrap_new__gpgme_op_assuan_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37282 0 : PyObject *resultobj = 0;
37283 0 : struct _gpgme_op_assuan_result *result = 0 ;
37284 :
37285 0 : if (!PyArg_ParseTuple(args,(char *)":new__gpgme_op_assuan_result")) SWIG_fail;
37286 : {
37287 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37288 0 : result = (struct _gpgme_op_assuan_result *)calloc(1, sizeof(struct _gpgme_op_assuan_result));
37289 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37290 : }
37291 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_op_assuan_result, SWIG_POINTER_NEW | 0 );
37292 0 : return resultobj;
37293 : fail:
37294 : return NULL;
37295 : }
37296 :
37297 :
37298 0 : SWIGINTERN PyObject *_wrap_delete__gpgme_op_assuan_result(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37299 0 : PyObject *resultobj = 0;
37300 0 : struct _gpgme_op_assuan_result *arg1 = (struct _gpgme_op_assuan_result *) 0 ;
37301 0 : void *argp1 = 0 ;
37302 0 : int res1 = 0 ;
37303 0 : PyObject * obj0 = 0 ;
37304 :
37305 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete__gpgme_op_assuan_result",&obj0)) SWIG_fail;
37306 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_op_assuan_result, SWIG_POINTER_DISOWN | 0 );
37307 0 : if (!SWIG_IsOK(res1)) {
37308 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete__gpgme_op_assuan_result" "', argument " "1"" of type '" "struct _gpgme_op_assuan_result *""'");
37309 : }
37310 0 : arg1 = (struct _gpgme_op_assuan_result *)(argp1);
37311 : {
37312 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37313 0 : free((char *) arg1);
37314 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37315 : }
37316 0 : resultobj = SWIG_Py_Void();
37317 0 : return resultobj;
37318 : fail:
37319 : return NULL;
37320 : }
37321 :
37322 :
37323 27 : SWIGINTERN PyObject *_gpgme_op_assuan_result_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37324 : PyObject *obj;
37325 27 : if (!PyArg_ParseTuple(args,(char*)"O:swigregister", &obj)) return NULL;
37326 54 : SWIG_TypeNewClientData(SWIGTYPE_p__gpgme_op_assuan_result, SWIG_NewClientData(obj));
37327 27 : return SWIG_Py_Void();
37328 : }
37329 :
37330 48 : SWIGINTERN PyObject *_wrap_new_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37331 48 : PyObject *resultobj = 0;
37332 48 : gpgme_ctx_t *result = 0 ;
37333 :
37334 48 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_ctx_t_p")) SWIG_fail;
37335 : {
37336 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37337 48 : result = (gpgme_ctx_t *)new_gpgme_ctx_t_p();
37338 48 : SWIG_PYTHON_THREAD_END_ALLOW;
37339 : }
37340 48 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
37341 48 : return resultobj;
37342 : fail:
37343 : return NULL;
37344 : }
37345 :
37346 :
37347 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37348 0 : PyObject *resultobj = 0;
37349 0 : gpgme_ctx_t arg1 = (gpgme_ctx_t) 0 ;
37350 0 : void *argp1 = 0 ;
37351 0 : int res1 = 0 ;
37352 0 : PyObject * obj0 = 0 ;
37353 0 : gpgme_ctx_t *result = 0 ;
37354 :
37355 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_ctx_t_p",&obj0)) SWIG_fail;
37356 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_context, 0 | 0 );
37357 0 : if (!SWIG_IsOK(res1)) {
37358 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t""'");
37359 : }
37360 0 : arg1 = (gpgme_ctx_t)(argp1);
37361 : {
37362 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37363 0 : result = (gpgme_ctx_t *)copy_gpgme_ctx_t_p(arg1);
37364 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37365 : }
37366 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_context, 0 | 0 );
37367 0 : return resultobj;
37368 : fail:
37369 : return NULL;
37370 : }
37371 :
37372 :
37373 48 : SWIGINTERN PyObject *_wrap_delete_gpgme_ctx_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37374 48 : PyObject *resultobj = 0;
37375 48 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
37376 48 : void *argp1 = 0 ;
37377 48 : int res1 = 0 ;
37378 48 : PyObject * obj0 = 0 ;
37379 :
37380 48 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_ctx_t_p",&obj0)) SWIG_fail;
37381 48 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
37382 48 : if (!SWIG_IsOK(res1)) {
37383 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_ctx_t_p" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
37384 : }
37385 48 : arg1 = (gpgme_ctx_t *)(argp1);
37386 : {
37387 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37388 48 : delete_gpgme_ctx_t_p(arg1);
37389 48 : SWIG_PYTHON_THREAD_END_ALLOW;
37390 : }
37391 48 : resultobj = SWIG_Py_Void();
37392 48 : return resultobj;
37393 : fail:
37394 : return NULL;
37395 : }
37396 :
37397 :
37398 0 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37399 0 : PyObject *resultobj = 0;
37400 0 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
37401 0 : gpgme_ctx_t arg2 = (gpgme_ctx_t) 0 ;
37402 0 : void *argp1 = 0 ;
37403 0 : int res1 = 0 ;
37404 0 : void *argp2 = 0 ;
37405 0 : int res2 = 0 ;
37406 0 : PyObject * obj0 = 0 ;
37407 0 : PyObject * obj1 = 0 ;
37408 :
37409 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_ctx_t_p_assign",&obj0,&obj1)) SWIG_fail;
37410 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
37411 0 : if (!SWIG_IsOK(res1)) {
37412 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_assign" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
37413 : }
37414 0 : arg1 = (gpgme_ctx_t *)(argp1);
37415 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_context, 0 | 0 );
37416 0 : if (!SWIG_IsOK(res2)) {
37417 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_ctx_t_p_assign" "', argument " "2"" of type '" "gpgme_ctx_t""'");
37418 : }
37419 0 : arg2 = (gpgme_ctx_t)(argp2);
37420 : {
37421 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37422 0 : gpgme_ctx_t_p_assign(arg1,arg2);
37423 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37424 : }
37425 0 : resultobj = SWIG_Py_Void();
37426 0 : return resultobj;
37427 : fail:
37428 : return NULL;
37429 : }
37430 :
37431 :
37432 48 : SWIGINTERN PyObject *_wrap_gpgme_ctx_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 48 : PyObject *resultobj = 0;
37434 48 : gpgme_ctx_t *arg1 = (gpgme_ctx_t *) 0 ;
37435 48 : void *argp1 = 0 ;
37436 48 : int res1 = 0 ;
37437 48 : PyObject * obj0 = 0 ;
37438 : gpgme_ctx_t result;
37439 :
37440 48 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_ctx_t_p_value",&obj0)) SWIG_fail;
37441 48 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_context, 0 | 0 );
37442 48 : if (!SWIG_IsOK(res1)) {
37443 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_ctx_t_p_value" "', argument " "1"" of type '" "gpgme_ctx_t *""'");
37444 : }
37445 48 : arg1 = (gpgme_ctx_t *)(argp1);
37446 : {
37447 48 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37448 48 : result = (gpgme_ctx_t)gpgme_ctx_t_p_value(arg1);
37449 48 : SWIG_PYTHON_THREAD_END_ALLOW;
37450 : }
37451 48 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_context, 0 | 0 );
37452 48 : return resultobj;
37453 : fail:
37454 : return NULL;
37455 : }
37456 :
37457 :
37458 108 : SWIGINTERN PyObject *_wrap_new_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37459 108 : PyObject *resultobj = 0;
37460 108 : gpgme_data_t *result = 0 ;
37461 :
37462 108 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_data_t_p")) SWIG_fail;
37463 : {
37464 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37465 108 : result = (gpgme_data_t *)new_gpgme_data_t_p();
37466 108 : SWIG_PYTHON_THREAD_END_ALLOW;
37467 : }
37468 108 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
37469 108 : return resultobj;
37470 : fail:
37471 : return NULL;
37472 : }
37473 :
37474 :
37475 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37476 0 : PyObject *resultobj = 0;
37477 0 : gpgme_data_t arg1 = (gpgme_data_t) 0 ;
37478 0 : void *argp1 = 0 ;
37479 0 : int res1 = 0 ;
37480 0 : PyObject * obj0 = 0 ;
37481 0 : gpgme_data_t *result = 0 ;
37482 :
37483 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_data_t_p",&obj0)) SWIG_fail;
37484 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpgme_data, 0 | 0 );
37485 0 : if (!SWIG_IsOK(res1)) {
37486 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t""'");
37487 : }
37488 0 : arg1 = (gpgme_data_t)(argp1);
37489 : {
37490 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37491 0 : result = (gpgme_data_t *)copy_gpgme_data_t_p(arg1);
37492 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37493 : }
37494 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p_gpgme_data, 0 | 0 );
37495 0 : return resultobj;
37496 : fail:
37497 : return NULL;
37498 : }
37499 :
37500 :
37501 108 : SWIGINTERN PyObject *_wrap_delete_gpgme_data_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37502 108 : PyObject *resultobj = 0;
37503 108 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
37504 108 : void *argp1 = 0 ;
37505 108 : int res1 = 0 ;
37506 108 : PyObject * obj0 = 0 ;
37507 :
37508 108 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_data_t_p",&obj0)) SWIG_fail;
37509 108 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
37510 108 : if (!SWIG_IsOK(res1)) {
37511 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_data_t_p" "', argument " "1"" of type '" "gpgme_data_t *""'");
37512 : }
37513 108 : arg1 = (gpgme_data_t *)(argp1);
37514 : {
37515 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37516 108 : delete_gpgme_data_t_p(arg1);
37517 108 : SWIG_PYTHON_THREAD_END_ALLOW;
37518 : }
37519 108 : resultobj = SWIG_Py_Void();
37520 108 : return resultobj;
37521 : fail:
37522 : return NULL;
37523 : }
37524 :
37525 :
37526 0 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37527 0 : PyObject *resultobj = 0;
37528 0 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
37529 0 : gpgme_data_t arg2 = (gpgme_data_t) 0 ;
37530 0 : void *argp1 = 0 ;
37531 0 : int res1 = 0 ;
37532 0 : void *argp2 = 0 ;
37533 0 : int res2 = 0 ;
37534 0 : PyObject * obj0 = 0 ;
37535 0 : PyObject * obj1 = 0 ;
37536 :
37537 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_data_t_p_assign",&obj0,&obj1)) SWIG_fail;
37538 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
37539 0 : if (!SWIG_IsOK(res1)) {
37540 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_assign" "', argument " "1"" of type '" "gpgme_data_t *""'");
37541 : }
37542 0 : arg1 = (gpgme_data_t *)(argp1);
37543 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_gpgme_data, 0 | 0 );
37544 0 : if (!SWIG_IsOK(res2)) {
37545 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_data_t_p_assign" "', argument " "2"" of type '" "gpgme_data_t""'");
37546 : }
37547 0 : arg2 = (gpgme_data_t)(argp2);
37548 : {
37549 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37550 0 : gpgme_data_t_p_assign(arg1,arg2);
37551 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37552 : }
37553 0 : resultobj = SWIG_Py_Void();
37554 0 : return resultobj;
37555 : fail:
37556 : return NULL;
37557 : }
37558 :
37559 :
37560 108 : SWIGINTERN PyObject *_wrap_gpgme_data_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37561 108 : PyObject *resultobj = 0;
37562 108 : gpgme_data_t *arg1 = (gpgme_data_t *) 0 ;
37563 108 : void *argp1 = 0 ;
37564 108 : int res1 = 0 ;
37565 108 : PyObject * obj0 = 0 ;
37566 : gpgme_data_t result;
37567 :
37568 108 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_data_t_p_value",&obj0)) SWIG_fail;
37569 108 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
37570 108 : if (!SWIG_IsOK(res1)) {
37571 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_data_t_p_value" "', argument " "1"" of type '" "gpgme_data_t *""'");
37572 : }
37573 108 : arg1 = (gpgme_data_t *)(argp1);
37574 : {
37575 108 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37576 108 : result = (gpgme_data_t)gpgme_data_t_p_value(arg1);
37577 108 : SWIG_PYTHON_THREAD_END_ALLOW;
37578 : }
37579 108 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpgme_data, 0 | 0 );
37580 108 : return resultobj;
37581 : fail:
37582 : return NULL;
37583 : }
37584 :
37585 :
37586 180 : SWIGINTERN PyObject *_wrap_new_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37587 180 : PyObject *resultobj = 0;
37588 180 : gpgme_key_t *result = 0 ;
37589 :
37590 180 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_key_t_p")) SWIG_fail;
37591 : {
37592 180 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37593 180 : result = (gpgme_key_t *)new_gpgme_key_t_p();
37594 180 : SWIG_PYTHON_THREAD_END_ALLOW;
37595 : }
37596 180 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
37597 180 : return resultobj;
37598 : fail:
37599 : return NULL;
37600 : }
37601 :
37602 :
37603 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37604 0 : PyObject *resultobj = 0;
37605 0 : gpgme_key_t arg1 = (gpgme_key_t) 0 ;
37606 0 : void *argp1 = 0 ;
37607 0 : int res1 = 0 ;
37608 0 : PyObject * obj0 = 0 ;
37609 0 : gpgme_key_t *result = 0 ;
37610 :
37611 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_key_t_p",&obj0)) SWIG_fail;
37612 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_key, 0 | 0 );
37613 0 : if (!SWIG_IsOK(res1)) {
37614 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t""'");
37615 : }
37616 0 : arg1 = (gpgme_key_t)(argp1);
37617 : {
37618 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37619 0 : result = (gpgme_key_t *)copy_gpgme_key_t_p(arg1);
37620 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37621 : }
37622 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_key, 0 | 0 );
37623 0 : return resultobj;
37624 : fail:
37625 : return NULL;
37626 : }
37627 :
37628 :
37629 178 : SWIGINTERN PyObject *_wrap_delete_gpgme_key_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37630 178 : PyObject *resultobj = 0;
37631 178 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
37632 178 : void *argp1 = 0 ;
37633 178 : int res1 = 0 ;
37634 178 : PyObject * obj0 = 0 ;
37635 :
37636 178 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_key_t_p",&obj0)) SWIG_fail;
37637 178 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
37638 178 : if (!SWIG_IsOK(res1)) {
37639 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_key_t_p" "', argument " "1"" of type '" "gpgme_key_t *""'");
37640 : }
37641 178 : arg1 = (gpgme_key_t *)(argp1);
37642 : {
37643 178 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37644 178 : delete_gpgme_key_t_p(arg1);
37645 178 : SWIG_PYTHON_THREAD_END_ALLOW;
37646 : }
37647 178 : resultobj = SWIG_Py_Void();
37648 178 : return resultobj;
37649 : fail:
37650 : return NULL;
37651 : }
37652 :
37653 :
37654 0 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37655 0 : PyObject *resultobj = 0;
37656 0 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
37657 0 : gpgme_key_t arg2 = (gpgme_key_t) 0 ;
37658 0 : void *argp1 = 0 ;
37659 0 : int res1 = 0 ;
37660 0 : void *argp2 = 0 ;
37661 0 : int res2 = 0 ;
37662 0 : PyObject * obj0 = 0 ;
37663 0 : PyObject * obj1 = 0 ;
37664 :
37665 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_key_t_p_assign",&obj0,&obj1)) SWIG_fail;
37666 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
37667 0 : if (!SWIG_IsOK(res1)) {
37668 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_assign" "', argument " "1"" of type '" "gpgme_key_t *""'");
37669 : }
37670 0 : arg1 = (gpgme_key_t *)(argp1);
37671 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_key, 0 | 0 );
37672 0 : if (!SWIG_IsOK(res2)) {
37673 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_key_t_p_assign" "', argument " "2"" of type '" "gpgme_key_t""'");
37674 : }
37675 0 : arg2 = (gpgme_key_t)(argp2);
37676 : {
37677 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37678 0 : gpgme_key_t_p_assign(arg1,arg2);
37679 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37680 : }
37681 0 : resultobj = SWIG_Py_Void();
37682 0 : return resultobj;
37683 : fail:
37684 : return NULL;
37685 : }
37686 :
37687 :
37688 164 : SWIGINTERN PyObject *_wrap_gpgme_key_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37689 164 : PyObject *resultobj = 0;
37690 164 : gpgme_key_t *arg1 = (gpgme_key_t *) 0 ;
37691 164 : void *argp1 = 0 ;
37692 164 : int res1 = 0 ;
37693 164 : PyObject * obj0 = 0 ;
37694 : gpgme_key_t result;
37695 :
37696 164 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_key_t_p_value",&obj0)) SWIG_fail;
37697 164 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_key, 0 | 0 );
37698 164 : if (!SWIG_IsOK(res1)) {
37699 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_key_t_p_value" "', argument " "1"" of type '" "gpgme_key_t *""'");
37700 : }
37701 164 : arg1 = (gpgme_key_t *)(argp1);
37702 : {
37703 164 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37704 164 : result = (gpgme_key_t)gpgme_key_t_p_value(arg1);
37705 164 : SWIG_PYTHON_THREAD_END_ALLOW;
37706 : }
37707 164 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_key, 0 | 0 );
37708 164 : return resultobj;
37709 : fail:
37710 : return NULL;
37711 : }
37712 :
37713 :
37714 16 : SWIGINTERN PyObject *_wrap_new_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37715 16 : PyObject *resultobj = 0;
37716 16 : gpgme_error_t *result = 0 ;
37717 :
37718 16 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_error_t_p")) SWIG_fail;
37719 : {
37720 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37721 16 : result = (gpgme_error_t *)new_gpgme_error_t_p();
37722 16 : SWIG_PYTHON_THREAD_END_ALLOW;
37723 : }
37724 16 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
37725 16 : return resultobj;
37726 : fail:
37727 : return NULL;
37728 : }
37729 :
37730 :
37731 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37732 0 : PyObject *resultobj = 0;
37733 : gpgme_error_t arg1 ;
37734 0 : PyObject * obj0 = 0 ;
37735 0 : gpgme_error_t *result = 0 ;
37736 :
37737 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_error_t_p",&obj0)) SWIG_fail;
37738 : {
37739 0 : if (PyLong_Check(obj0))
37740 0 : arg1 = PyLong_AsLong(obj0);
37741 :
37742 0 : else if (PyInt_Check(obj0))
37743 0 : arg1 = PyInt_AsLong(obj0);
37744 :
37745 : else
37746 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
37747 : }
37748 : {
37749 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37750 0 : result = (gpgme_error_t *)copy_gpgme_error_t_p(arg1);
37751 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37752 : }
37753 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_gpg_error_t, 0 | 0 );
37754 0 : return resultobj;
37755 : fail:
37756 : return NULL;
37757 : }
37758 :
37759 :
37760 16 : SWIGINTERN PyObject *_wrap_delete_gpgme_error_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37761 16 : PyObject *resultobj = 0;
37762 16 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
37763 16 : void *argp1 = 0 ;
37764 16 : int res1 = 0 ;
37765 16 : PyObject * obj0 = 0 ;
37766 :
37767 16 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_error_t_p",&obj0)) SWIG_fail;
37768 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
37769 16 : if (!SWIG_IsOK(res1)) {
37770 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_error_t_p" "', argument " "1"" of type '" "gpgme_error_t *""'");
37771 : }
37772 16 : arg1 = (gpgme_error_t *)(argp1);
37773 : {
37774 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37775 16 : delete_gpgme_error_t_p(arg1);
37776 16 : SWIG_PYTHON_THREAD_END_ALLOW;
37777 : }
37778 16 : resultobj = SWIG_Py_Void();
37779 16 : return resultobj;
37780 : fail:
37781 : return NULL;
37782 : }
37783 :
37784 :
37785 0 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37786 0 : PyObject *resultobj = 0;
37787 0 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
37788 : gpgme_error_t arg2 ;
37789 0 : void *argp1 = 0 ;
37790 0 : int res1 = 0 ;
37791 0 : PyObject * obj0 = 0 ;
37792 0 : PyObject * obj1 = 0 ;
37793 :
37794 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_error_t_p_assign",&obj0,&obj1)) SWIG_fail;
37795 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
37796 0 : if (!SWIG_IsOK(res1)) {
37797 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_assign" "', argument " "1"" of type '" "gpgme_error_t *""'");
37798 : }
37799 0 : arg1 = (gpgme_error_t *)(argp1);
37800 : {
37801 0 : if (PyLong_Check(obj1))
37802 0 : arg2 = PyLong_AsLong(obj1);
37803 :
37804 0 : else if (PyInt_Check(obj1))
37805 0 : arg2 = PyInt_AsLong(obj1);
37806 :
37807 : else
37808 0 : PyErr_SetString(PyExc_TypeError, "Numeric argument expected");
37809 : }
37810 : {
37811 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37812 0 : gpgme_error_t_p_assign(arg1,arg2);
37813 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37814 : }
37815 0 : resultobj = SWIG_Py_Void();
37816 0 : return resultobj;
37817 : fail:
37818 : return NULL;
37819 : }
37820 :
37821 :
37822 16 : SWIGINTERN PyObject *_wrap_gpgme_error_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37823 16 : PyObject *resultobj = 0;
37824 16 : gpgme_error_t *arg1 = (gpgme_error_t *) 0 ;
37825 16 : void *argp1 = 0 ;
37826 16 : int res1 = 0 ;
37827 16 : PyObject * obj0 = 0 ;
37828 : gpgme_error_t result;
37829 :
37830 16 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_error_t_p_value",&obj0)) SWIG_fail;
37831 16 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_gpg_error_t, 0 | 0 );
37832 16 : if (!SWIG_IsOK(res1)) {
37833 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_error_t_p_value" "', argument " "1"" of type '" "gpgme_error_t *""'");
37834 : }
37835 16 : arg1 = (gpgme_error_t *)(argp1);
37836 : {
37837 16 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37838 16 : result = gpgme_error_t_p_value(arg1);
37839 16 : SWIG_PYTHON_THREAD_END_ALLOW;
37840 : }
37841 : {
37842 16 : resultobj = PyLong_FromLong(result);
37843 : }
37844 16 : return resultobj;
37845 : fail:
37846 : return NULL;
37847 : }
37848 :
37849 :
37850 2 : SWIGINTERN PyObject *_wrap_new_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37851 2 : PyObject *resultobj = 0;
37852 2 : gpgme_trust_item_t *result = 0 ;
37853 :
37854 2 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_trust_item_t_p")) SWIG_fail;
37855 : {
37856 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37857 2 : result = (gpgme_trust_item_t *)new_gpgme_trust_item_t_p();
37858 2 : SWIG_PYTHON_THREAD_END_ALLOW;
37859 : }
37860 2 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37861 2 : return resultobj;
37862 : fail:
37863 : return NULL;
37864 : }
37865 :
37866 :
37867 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37868 0 : PyObject *resultobj = 0;
37869 0 : gpgme_trust_item_t arg1 = (gpgme_trust_item_t) 0 ;
37870 0 : void *argp1 = 0 ;
37871 0 : int res1 = 0 ;
37872 0 : PyObject * obj0 = 0 ;
37873 0 : gpgme_trust_item_t *result = 0 ;
37874 :
37875 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
37876 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37877 0 : if (!SWIG_IsOK(res1)) {
37878 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t""'");
37879 : }
37880 0 : arg1 = (gpgme_trust_item_t)(argp1);
37881 : {
37882 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37883 0 : result = (gpgme_trust_item_t *)copy_gpgme_trust_item_t_p(arg1);
37884 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37885 : }
37886 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37887 0 : return resultobj;
37888 : fail:
37889 : return NULL;
37890 : }
37891 :
37892 :
37893 2 : SWIGINTERN PyObject *_wrap_delete_gpgme_trust_item_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37894 2 : PyObject *resultobj = 0;
37895 2 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
37896 2 : void *argp1 = 0 ;
37897 2 : int res1 = 0 ;
37898 2 : PyObject * obj0 = 0 ;
37899 :
37900 2 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_trust_item_t_p",&obj0)) SWIG_fail;
37901 2 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37902 2 : if (!SWIG_IsOK(res1)) {
37903 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_trust_item_t_p" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
37904 : }
37905 2 : arg1 = (gpgme_trust_item_t *)(argp1);
37906 : {
37907 2 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37908 2 : delete_gpgme_trust_item_t_p(arg1);
37909 2 : SWIG_PYTHON_THREAD_END_ALLOW;
37910 : }
37911 2 : resultobj = SWIG_Py_Void();
37912 2 : return resultobj;
37913 : fail:
37914 : return NULL;
37915 : }
37916 :
37917 :
37918 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37919 0 : PyObject *resultobj = 0;
37920 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
37921 0 : gpgme_trust_item_t arg2 = (gpgme_trust_item_t) 0 ;
37922 0 : void *argp1 = 0 ;
37923 0 : int res1 = 0 ;
37924 0 : void *argp2 = 0 ;
37925 0 : int res2 = 0 ;
37926 0 : PyObject * obj0 = 0 ;
37927 0 : PyObject * obj1 = 0 ;
37928 :
37929 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_trust_item_t_p_assign",&obj0,&obj1)) SWIG_fail;
37930 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37931 0 : if (!SWIG_IsOK(res1)) {
37932 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
37933 : }
37934 0 : arg1 = (gpgme_trust_item_t *)(argp1);
37935 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37936 0 : if (!SWIG_IsOK(res2)) {
37937 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_trust_item_t_p_assign" "', argument " "2"" of type '" "gpgme_trust_item_t""'");
37938 : }
37939 0 : arg2 = (gpgme_trust_item_t)(argp2);
37940 : {
37941 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37942 0 : gpgme_trust_item_t_p_assign(arg1,arg2);
37943 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37944 : }
37945 0 : resultobj = SWIG_Py_Void();
37946 0 : return resultobj;
37947 : fail:
37948 : return NULL;
37949 : }
37950 :
37951 :
37952 0 : SWIGINTERN PyObject *_wrap_gpgme_trust_item_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37953 0 : PyObject *resultobj = 0;
37954 0 : gpgme_trust_item_t *arg1 = (gpgme_trust_item_t *) 0 ;
37955 0 : void *argp1 = 0 ;
37956 0 : int res1 = 0 ;
37957 0 : PyObject * obj0 = 0 ;
37958 : gpgme_trust_item_t result;
37959 :
37960 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_trust_item_t_p_value",&obj0)) SWIG_fail;
37961 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_trust_item, 0 | 0 );
37962 0 : if (!SWIG_IsOK(res1)) {
37963 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_trust_item_t_p_value" "', argument " "1"" of type '" "gpgme_trust_item_t *""'");
37964 : }
37965 0 : arg1 = (gpgme_trust_item_t *)(argp1);
37966 : {
37967 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37968 0 : result = (gpgme_trust_item_t)gpgme_trust_item_t_p_value(arg1);
37969 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37970 : }
37971 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p__gpgme_trust_item, 0 | 0 );
37972 0 : return resultobj;
37973 : fail:
37974 : return NULL;
37975 : }
37976 :
37977 :
37978 0 : SWIGINTERN PyObject *_wrap_new_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37979 0 : PyObject *resultobj = 0;
37980 0 : gpgme_engine_info_t *result = 0 ;
37981 :
37982 0 : if (!PyArg_ParseTuple(args,(char *)":new_gpgme_engine_info_t_p")) SWIG_fail;
37983 : {
37984 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
37985 0 : result = (gpgme_engine_info_t *)new_gpgme_engine_info_t_p();
37986 0 : SWIG_PYTHON_THREAD_END_ALLOW;
37987 : }
37988 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
37989 0 : return resultobj;
37990 : fail:
37991 : return NULL;
37992 : }
37993 :
37994 :
37995 0 : SWIGINTERN PyObject *_wrap_copy_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37996 0 : PyObject *resultobj = 0;
37997 0 : gpgme_engine_info_t arg1 = (gpgme_engine_info_t) 0 ;
37998 0 : void *argp1 = 0 ;
37999 0 : int res1 = 0 ;
38000 0 : PyObject * obj0 = 0 ;
38001 0 : gpgme_engine_info_t *result = 0 ;
38002 :
38003 0 : if (!PyArg_ParseTuple(args,(char *)"O:copy_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
38004 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
38005 0 : if (!SWIG_IsOK(res1)) {
38006 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "copy_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t""'");
38007 : }
38008 0 : arg1 = (gpgme_engine_info_t)(argp1);
38009 : {
38010 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38011 0 : result = (gpgme_engine_info_t *)copy_gpgme_engine_info_t_p(arg1);
38012 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38013 : }
38014 0 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
38015 0 : return resultobj;
38016 : fail:
38017 : return NULL;
38018 : }
38019 :
38020 :
38021 0 : SWIGINTERN PyObject *_wrap_delete_gpgme_engine_info_t_p(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38022 0 : PyObject *resultobj = 0;
38023 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
38024 0 : void *argp1 = 0 ;
38025 0 : int res1 = 0 ;
38026 0 : PyObject * obj0 = 0 ;
38027 :
38028 0 : if (!PyArg_ParseTuple(args,(char *)"O:delete_gpgme_engine_info_t_p",&obj0)) SWIG_fail;
38029 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
38030 0 : if (!SWIG_IsOK(res1)) {
38031 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_gpgme_engine_info_t_p" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
38032 : }
38033 0 : arg1 = (gpgme_engine_info_t *)(argp1);
38034 : {
38035 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38036 0 : delete_gpgme_engine_info_t_p(arg1);
38037 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38038 : }
38039 0 : resultobj = SWIG_Py_Void();
38040 0 : return resultobj;
38041 : fail:
38042 : return NULL;
38043 : }
38044 :
38045 :
38046 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_assign(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38047 0 : PyObject *resultobj = 0;
38048 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
38049 0 : gpgme_engine_info_t arg2 = (gpgme_engine_info_t) 0 ;
38050 0 : void *argp1 = 0 ;
38051 0 : int res1 = 0 ;
38052 0 : void *argp2 = 0 ;
38053 0 : int res2 = 0 ;
38054 0 : PyObject * obj0 = 0 ;
38055 0 : PyObject * obj1 = 0 ;
38056 :
38057 0 : if (!PyArg_ParseTuple(args,(char *)"OO:gpgme_engine_info_t_p_assign",&obj0,&obj1)) SWIG_fail;
38058 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
38059 0 : if (!SWIG_IsOK(res1)) {
38060 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
38061 : }
38062 0 : arg1 = (gpgme_engine_info_t *)(argp1);
38063 0 : res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p__gpgme_engine_info, 0 | 0 );
38064 0 : if (!SWIG_IsOK(res2)) {
38065 0 : SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "gpgme_engine_info_t_p_assign" "', argument " "2"" of type '" "gpgme_engine_info_t""'");
38066 : }
38067 0 : arg2 = (gpgme_engine_info_t)(argp2);
38068 : {
38069 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38070 0 : gpgme_engine_info_t_p_assign(arg1,arg2);
38071 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38072 : }
38073 0 : resultobj = SWIG_Py_Void();
38074 0 : return resultobj;
38075 : fail:
38076 : return NULL;
38077 : }
38078 :
38079 :
38080 0 : SWIGINTERN PyObject *_wrap_gpgme_engine_info_t_p_value(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38081 0 : PyObject *resultobj = 0;
38082 0 : gpgme_engine_info_t *arg1 = (gpgme_engine_info_t *) 0 ;
38083 0 : void *argp1 = 0 ;
38084 0 : int res1 = 0 ;
38085 0 : PyObject * obj0 = 0 ;
38086 : gpgme_engine_info_t result;
38087 :
38088 0 : if (!PyArg_ParseTuple(args,(char *)"O:gpgme_engine_info_t_p_value",&obj0)) SWIG_fail;
38089 0 : res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_p__gpgme_engine_info, 0 | 0 );
38090 0 : if (!SWIG_IsOK(res1)) {
38091 0 : SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "gpgme_engine_info_t_p_value" "', argument " "1"" of type '" "gpgme_engine_info_t *""'");
38092 : }
38093 0 : arg1 = (gpgme_engine_info_t *)(argp1);
38094 : {
38095 0 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38096 0 : result = (gpgme_engine_info_t)gpgme_engine_info_t_p_value(arg1);
38097 0 : SWIG_PYTHON_THREAD_END_ALLOW;
38098 : }
38099 : {
38100 : int i;
38101 0 : int size = 0;
38102 : gpgme_engine_info_t curr;
38103 0 : for (curr = result; curr != NULL; curr = curr->next) {
38104 0 : size++;
38105 : }
38106 0 : resultobj = PyList_New(size);
38107 0 : if (resultobj == NULL)
38108 : return NULL; /* raise */
38109 0 : for (i=0,curr=result; i<size; i++,curr=curr->next) {
38110 : PyObject *fragile, *o;
38111 0 : fragile = SWIG_NewPointerObj(SWIG_as_voidptr(curr), SWIGTYPE_p__gpgme_engine_info,
38112 : 0 );
38113 0 : if (fragile == NULL)
38114 : {
38115 0 : Py_DECREF(resultobj);
38116 : return NULL; /* raise */
38117 : }
38118 0 : o = _gpg_wrap_result(fragile, "EngineInfo");
38119 0 : Py_DECREF(fragile);
38120 0 : if (o == NULL)
38121 : {
38122 0 : Py_DECREF(resultobj);
38123 : return NULL; /* raise */
38124 : }
38125 0 : PyList_SetItem(resultobj, i, o);
38126 : }
38127 : }
38128 : return resultobj;
38129 : fail:
38130 : return NULL;
38131 : }
38132 :
38133 :
38134 1 : SWIGINTERN PyObject *_wrap_fdopen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38135 1 : PyObject *resultobj = 0;
38136 : int arg1 ;
38137 1 : char *arg2 = (char *) 0 ;
38138 : int val1 ;
38139 1 : int ecode1 = 0 ;
38140 1 : PyObject *encodedInput2 = NULL ;
38141 1 : PyObject * obj0 = 0 ;
38142 1 : PyObject * obj1 = 0 ;
38143 1 : FILE *result = 0 ;
38144 :
38145 1 : if (!PyArg_ParseTuple(args,(char *)"OO:fdopen",&obj0,&obj1)) SWIG_fail;
38146 2 : ecode1 = SWIG_AsVal_int(obj0, &val1);
38147 1 : if (!SWIG_IsOK(ecode1)) {
38148 0 : SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "fdopen" "', argument " "1"" of type '" "int""'");
38149 : }
38150 1 : arg1 = (int)(val1);
38151 : {
38152 1 : if (obj1 == Py_None)
38153 : arg2 = NULL;
38154 1 : else if (PyUnicode_Check(obj1))
38155 : {
38156 0 : encodedInput2 = PyUnicode_AsUTF8String(obj1);
38157 0 : if (encodedInput2 == NULL)
38158 : return NULL;
38159 0 : arg2 = PyBytes_AsString(encodedInput2);
38160 : }
38161 1 : else if (PyBytes_Check(obj1))
38162 1 : arg2 = PyBytes_AsString(obj1);
38163 : else {
38164 0 : PyErr_Format(PyExc_TypeError,
38165 : "arg %d: expected str, bytes, or None, got %s",
38166 : 2, obj1->ob_type->tp_name);
38167 0 : return NULL;
38168 : }
38169 : }
38170 : {
38171 1 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38172 1 : result = (FILE *)fdopen(arg1,(char const *)arg2);
38173 1 : SWIG_PYTHON_THREAD_END_ALLOW;
38174 : }
38175 1 : resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_FILE, 0 | 0 );
38176 : {
38177 1 : Py_XDECREF(encodedInput2);
38178 : }
38179 : return resultobj;
38180 : fail:
38181 : {
38182 : Py_XDECREF(encodedInput2);
38183 : }
38184 : return NULL;
38185 : }
38186 :
38187 :
38188 0 : SWIGINTERN int Swig_var_gpg_in_tree_build_set(PyObject *_val) {
38189 : {
38190 : int val;
38191 0 : int res = SWIG_AsVal_int(_val, &val);
38192 0 : if (!SWIG_IsOK(res)) {
38193 0 : SWIG_exception_fail(SWIG_ArgError(res), "in variable '""gpg_in_tree_build""' of type '""int""'");
38194 : }
38195 0 : gpg_in_tree_build = (int)(val);
38196 : }
38197 0 : return 0;
38198 : fail:
38199 0 : return 1;
38200 : }
38201 :
38202 :
38203 27 : SWIGINTERN PyObject *Swig_var_gpg_in_tree_build_get(void) {
38204 27 : PyObject *pyobj = 0;
38205 :
38206 54 : pyobj = SWIG_From_int((int)(gpg_in_tree_build));
38207 27 : return pyobj;
38208 : }
38209 :
38210 :
38211 12 : SWIGINTERN PyObject *_wrap_gpg_raise_callback_exception(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38212 12 : PyObject *resultobj = 0;
38213 12 : PyObject *arg1 = (PyObject *) 0 ;
38214 12 : PyObject * obj0 = 0 ;
38215 12 : PyObject *result = 0 ;
38216 :
38217 12 : if (!PyArg_ParseTuple(args,(char *)"O:gpg_raise_callback_exception",&obj0)) SWIG_fail;
38218 12 : arg1 = obj0;
38219 : {
38220 12 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38221 12 : result = (PyObject *)gpg_raise_callback_exception(arg1);
38222 12 : SWIG_PYTHON_THREAD_END_ALLOW;
38223 : }
38224 12 : resultobj = result;
38225 12 : return resultobj;
38226 : fail:
38227 : return NULL;
38228 : }
38229 :
38230 :
38231 91 : SWIGINTERN PyObject *_wrap_gpg_set_passphrase_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38232 91 : PyObject *resultobj = 0;
38233 91 : PyObject *arg1 = (PyObject *) 0 ;
38234 91 : PyObject *arg2 = (PyObject *) 0 ;
38235 91 : PyObject * obj0 = 0 ;
38236 91 : PyObject * obj1 = 0 ;
38237 91 : PyObject *result = 0 ;
38238 :
38239 91 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_passphrase_cb",&obj0,&obj1)) SWIG_fail;
38240 91 : arg1 = obj0;
38241 91 : arg2 = obj1;
38242 : {
38243 91 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38244 91 : result = (PyObject *)gpg_set_passphrase_cb(arg1,arg2);
38245 91 : SWIG_PYTHON_THREAD_END_ALLOW;
38246 : }
38247 91 : resultobj = result;
38248 91 : return resultobj;
38249 : fail:
38250 : return NULL;
38251 : }
38252 :
38253 :
38254 67 : SWIGINTERN PyObject *_wrap_gpg_set_progress_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38255 67 : PyObject *resultobj = 0;
38256 67 : PyObject *arg1 = (PyObject *) 0 ;
38257 67 : PyObject *arg2 = (PyObject *) 0 ;
38258 67 : PyObject * obj0 = 0 ;
38259 67 : PyObject * obj1 = 0 ;
38260 67 : PyObject *result = 0 ;
38261 :
38262 67 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_progress_cb",&obj0,&obj1)) SWIG_fail;
38263 67 : arg1 = obj0;
38264 67 : arg2 = obj1;
38265 : {
38266 67 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38267 67 : result = (PyObject *)gpg_set_progress_cb(arg1,arg2);
38268 67 : SWIG_PYTHON_THREAD_END_ALLOW;
38269 : }
38270 67 : resultobj = result;
38271 67 : return resultobj;
38272 : fail:
38273 : return NULL;
38274 : }
38275 :
38276 :
38277 67 : SWIGINTERN PyObject *_wrap_gpg_set_status_cb(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38278 67 : PyObject *resultobj = 0;
38279 67 : PyObject *arg1 = (PyObject *) 0 ;
38280 67 : PyObject *arg2 = (PyObject *) 0 ;
38281 67 : PyObject * obj0 = 0 ;
38282 67 : PyObject * obj1 = 0 ;
38283 67 : PyObject *result = 0 ;
38284 :
38285 67 : if (!PyArg_ParseTuple(args,(char *)"OO:gpg_set_status_cb",&obj0,&obj1)) SWIG_fail;
38286 67 : arg1 = obj0;
38287 67 : arg2 = obj1;
38288 : {
38289 67 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38290 67 : result = (PyObject *)gpg_set_status_cb(arg1,arg2);
38291 67 : SWIG_PYTHON_THREAD_END_ALLOW;
38292 : }
38293 67 : resultobj = result;
38294 67 : return resultobj;
38295 : fail:
38296 : return NULL;
38297 : }
38298 :
38299 :
38300 10 : SWIGINTERN PyObject *_wrap_gpg_data_new_from_cbs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38301 10 : PyObject *resultobj = 0;
38302 10 : PyObject *arg1 = (PyObject *) 0 ;
38303 10 : PyObject *arg2 = (PyObject *) 0 ;
38304 10 : gpgme_data_t *arg3 = (gpgme_data_t *) 0 ;
38305 10 : void *argp3 = 0 ;
38306 10 : int res3 = 0 ;
38307 10 : PyObject * obj0 = 0 ;
38308 10 : PyObject * obj1 = 0 ;
38309 10 : PyObject * obj2 = 0 ;
38310 10 : PyObject *result = 0 ;
38311 :
38312 10 : if (!PyArg_ParseTuple(args,(char *)"OOO:gpg_data_new_from_cbs",&obj0,&obj1,&obj2)) SWIG_fail;
38313 10 : arg1 = obj0;
38314 10 : arg2 = obj1;
38315 10 : res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_p_gpgme_data, 0 | 0 );
38316 10 : if (!SWIG_IsOK(res3)) {
38317 0 : SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "gpg_data_new_from_cbs" "', argument " "3"" of type '" "gpgme_data_t *""'");
38318 : }
38319 10 : arg3 = (gpgme_data_t *)(argp3);
38320 : {
38321 10 : SWIG_PYTHON_THREAD_BEGIN_ALLOW;
38322 10 : result = (PyObject *)gpg_data_new_from_cbs(arg1,arg2,arg3);
38323 10 : SWIG_PYTHON_THREAD_END_ALLOW;
38324 : }
38325 10 : resultobj = result;
38326 10 : return resultobj;
38327 : fail:
38328 : return NULL;
38329 : }
38330 :
38331 :
38332 : static PyMethodDef SwigMethods[] = {
38333 : { (char *)"SWIG_PyInstanceMethod_New", (PyCFunction)SWIG_PyInstanceMethod_New, METH_O, NULL},
38334 : { (char *)"gpgme_op_keylist_start", _wrap_gpgme_op_keylist_start, METH_VARARGS, (char *)"gpgme_op_keylist_start(ctx, pattern, secret_only=0) -> gpgme_error_t"},
38335 : { (char *)"_gpgme_sig_notation_name_set", _wrap__gpgme_sig_notation_name_set, METH_VARARGS, (char *)"_gpgme_sig_notation_name_set(self, name)"},
38336 : { (char *)"_gpgme_sig_notation_name_get", _wrap__gpgme_sig_notation_name_get, METH_VARARGS, (char *)"_gpgme_sig_notation_name_get(self) -> char *"},
38337 : { (char *)"_gpgme_sig_notation_value_set", _wrap__gpgme_sig_notation_value_set, METH_VARARGS, (char *)"_gpgme_sig_notation_value_set(self, value)"},
38338 : { (char *)"_gpgme_sig_notation_value_get", _wrap__gpgme_sig_notation_value_get, METH_VARARGS, (char *)"_gpgme_sig_notation_value_get(self) -> char *"},
38339 : { (char *)"_gpgme_sig_notation_flags_set", _wrap__gpgme_sig_notation_flags_set, METH_VARARGS, (char *)"_gpgme_sig_notation_flags_set(self, flags)"},
38340 : { (char *)"_gpgme_sig_notation_flags_get", _wrap__gpgme_sig_notation_flags_get, METH_VARARGS, (char *)"_gpgme_sig_notation_flags_get(self) -> gpgme_sig_notation_flags_t"},
38341 : { (char *)"_gpgme_sig_notation_human_readable_set", _wrap__gpgme_sig_notation_human_readable_set, METH_VARARGS, (char *)"_gpgme_sig_notation_human_readable_set(self, human_readable)"},
38342 : { (char *)"_gpgme_sig_notation_human_readable_get", _wrap__gpgme_sig_notation_human_readable_get, METH_VARARGS, (char *)"_gpgme_sig_notation_human_readable_get(self) -> unsigned int"},
38343 : { (char *)"_gpgme_sig_notation_critical_set", _wrap__gpgme_sig_notation_critical_set, METH_VARARGS, (char *)"_gpgme_sig_notation_critical_set(self, critical)"},
38344 : { (char *)"_gpgme_sig_notation_critical_get", _wrap__gpgme_sig_notation_critical_get, METH_VARARGS, (char *)"_gpgme_sig_notation_critical_get(self) -> unsigned int"},
38345 : { (char *)"new__gpgme_sig_notation", _wrap_new__gpgme_sig_notation, METH_VARARGS, (char *)"new__gpgme_sig_notation() -> _gpgme_sig_notation"},
38346 : { (char *)"delete__gpgme_sig_notation", _wrap_delete__gpgme_sig_notation, METH_VARARGS, (char *)"delete__gpgme_sig_notation(self)"},
38347 : { (char *)"_gpgme_sig_notation_swigregister", _gpgme_sig_notation_swigregister, METH_VARARGS, NULL},
38348 : { (char *)"gpgme_err_make", _wrap_gpgme_err_make, METH_VARARGS, (char *)"gpgme_err_make(source, code) -> gpgme_error_t"},
38349 : { (char *)"gpgme_error", _wrap_gpgme_error, METH_VARARGS, (char *)"gpgme_error(code) -> gpgme_error_t"},
38350 : { (char *)"gpgme_err_code", _wrap_gpgme_err_code, METH_VARARGS, (char *)"gpgme_err_code(err) -> gpgme_err_code_t"},
38351 : { (char *)"gpgme_err_source", _wrap_gpgme_err_source, METH_VARARGS, (char *)"gpgme_err_source(err) -> gpgme_err_source_t"},
38352 : { (char *)"gpgme_strerror", _wrap_gpgme_strerror, METH_VARARGS, (char *)"gpgme_strerror(err) -> char const *"},
38353 : { (char *)"gpgme_strerror_r", _wrap_gpgme_strerror_r, METH_VARARGS, (char *)"gpgme_strerror_r(err, buf) -> int"},
38354 : { (char *)"gpgme_strsource", _wrap_gpgme_strsource, METH_VARARGS, (char *)"gpgme_strsource(err) -> char const *"},
38355 : { (char *)"gpgme_err_code_from_errno", _wrap_gpgme_err_code_from_errno, METH_VARARGS, (char *)"gpgme_err_code_from_errno(err) -> gpgme_err_code_t"},
38356 : { (char *)"gpgme_err_code_to_errno", _wrap_gpgme_err_code_to_errno, METH_VARARGS, (char *)"gpgme_err_code_to_errno(code) -> int"},
38357 : { (char *)"gpgme_err_code_from_syserror", _wrap_gpgme_err_code_from_syserror, METH_VARARGS, (char *)"gpgme_err_code_from_syserror() -> gpgme_err_code_t"},
38358 : { (char *)"gpgme_err_set_errno", _wrap_gpgme_err_set_errno, METH_VARARGS, (char *)"gpgme_err_set_errno(err)"},
38359 : { (char *)"gpgme_err_make_from_errno", _wrap_gpgme_err_make_from_errno, METH_VARARGS, (char *)"gpgme_err_make_from_errno(source, err) -> gpgme_error_t"},
38360 : { (char *)"gpgme_error_from_errno", _wrap_gpgme_error_from_errno, METH_VARARGS, (char *)"gpgme_error_from_errno(err) -> gpgme_error_t"},
38361 : { (char *)"gpgme_error_from_syserror", _wrap_gpgme_error_from_syserror, METH_VARARGS, (char *)"gpgme_error_from_syserror() -> gpgme_error_t"},
38362 : { (char *)"_gpgme_engine_info_protocol_set", _wrap__gpgme_engine_info_protocol_set, METH_VARARGS, (char *)"_gpgme_engine_info_protocol_set(self, protocol)"},
38363 : { (char *)"_gpgme_engine_info_protocol_get", _wrap__gpgme_engine_info_protocol_get, METH_VARARGS, (char *)"_gpgme_engine_info_protocol_get(self) -> gpgme_protocol_t"},
38364 : { (char *)"_gpgme_engine_info_file_name_set", _wrap__gpgme_engine_info_file_name_set, METH_VARARGS, (char *)"_gpgme_engine_info_file_name_set(self, file_name)"},
38365 : { (char *)"_gpgme_engine_info_file_name_get", _wrap__gpgme_engine_info_file_name_get, METH_VARARGS, (char *)"_gpgme_engine_info_file_name_get(self) -> char *"},
38366 : { (char *)"_gpgme_engine_info_version_set", _wrap__gpgme_engine_info_version_set, METH_VARARGS, (char *)"_gpgme_engine_info_version_set(self, version)"},
38367 : { (char *)"_gpgme_engine_info_version_get", _wrap__gpgme_engine_info_version_get, METH_VARARGS, (char *)"_gpgme_engine_info_version_get(self) -> char *"},
38368 : { (char *)"_gpgme_engine_info_req_version_set", _wrap__gpgme_engine_info_req_version_set, METH_VARARGS, (char *)"_gpgme_engine_info_req_version_set(self, req_version)"},
38369 : { (char *)"_gpgme_engine_info_req_version_get", _wrap__gpgme_engine_info_req_version_get, METH_VARARGS, (char *)"_gpgme_engine_info_req_version_get(self) -> char const *"},
38370 : { (char *)"_gpgme_engine_info_home_dir_set", _wrap__gpgme_engine_info_home_dir_set, METH_VARARGS, (char *)"_gpgme_engine_info_home_dir_set(self, home_dir)"},
38371 : { (char *)"_gpgme_engine_info_home_dir_get", _wrap__gpgme_engine_info_home_dir_get, METH_VARARGS, (char *)"_gpgme_engine_info_home_dir_get(self) -> char *"},
38372 : { (char *)"new__gpgme_engine_info", _wrap_new__gpgme_engine_info, METH_VARARGS, (char *)"new__gpgme_engine_info() -> _gpgme_engine_info"},
38373 : { (char *)"delete__gpgme_engine_info", _wrap_delete__gpgme_engine_info, METH_VARARGS, (char *)"delete__gpgme_engine_info(self)"},
38374 : { (char *)"_gpgme_engine_info_swigregister", _gpgme_engine_info_swigregister, METH_VARARGS, NULL},
38375 : { (char *)"_gpgme_tofu_info_validity_set", _wrap__gpgme_tofu_info_validity_set, METH_VARARGS, (char *)"_gpgme_tofu_info_validity_set(self, validity)"},
38376 : { (char *)"_gpgme_tofu_info_validity_get", _wrap__gpgme_tofu_info_validity_get, METH_VARARGS, (char *)"_gpgme_tofu_info_validity_get(self) -> unsigned int"},
38377 : { (char *)"_gpgme_tofu_info_policy_set", _wrap__gpgme_tofu_info_policy_set, METH_VARARGS, (char *)"_gpgme_tofu_info_policy_set(self, policy)"},
38378 : { (char *)"_gpgme_tofu_info_policy_get", _wrap__gpgme_tofu_info_policy_get, METH_VARARGS, (char *)"_gpgme_tofu_info_policy_get(self) -> unsigned int"},
38379 : { (char *)"_gpgme_tofu_info__rfu_set", _wrap__gpgme_tofu_info__rfu_set, METH_VARARGS, (char *)"_gpgme_tofu_info__rfu_set(self, _rfu)"},
38380 : { (char *)"_gpgme_tofu_info__rfu_get", _wrap__gpgme_tofu_info__rfu_get, METH_VARARGS, (char *)"_gpgme_tofu_info__rfu_get(self) -> unsigned int"},
38381 : { (char *)"_gpgme_tofu_info_signcount_set", _wrap__gpgme_tofu_info_signcount_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signcount_set(self, signcount)"},
38382 : { (char *)"_gpgme_tofu_info_signcount_get", _wrap__gpgme_tofu_info_signcount_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signcount_get(self) -> unsigned short"},
38383 : { (char *)"_gpgme_tofu_info_encrcount_set", _wrap__gpgme_tofu_info_encrcount_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrcount_set(self, encrcount)"},
38384 : { (char *)"_gpgme_tofu_info_encrcount_get", _wrap__gpgme_tofu_info_encrcount_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrcount_get(self) -> unsigned short"},
38385 : { (char *)"_gpgme_tofu_info_signfirst_set", _wrap__gpgme_tofu_info_signfirst_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signfirst_set(self, signfirst)"},
38386 : { (char *)"_gpgme_tofu_info_signfirst_get", _wrap__gpgme_tofu_info_signfirst_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signfirst_get(self) -> unsigned long"},
38387 : { (char *)"_gpgme_tofu_info_signlast_set", _wrap__gpgme_tofu_info_signlast_set, METH_VARARGS, (char *)"_gpgme_tofu_info_signlast_set(self, signlast)"},
38388 : { (char *)"_gpgme_tofu_info_signlast_get", _wrap__gpgme_tofu_info_signlast_get, METH_VARARGS, (char *)"_gpgme_tofu_info_signlast_get(self) -> unsigned long"},
38389 : { (char *)"_gpgme_tofu_info_encrfirst_set", _wrap__gpgme_tofu_info_encrfirst_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrfirst_set(self, encrfirst)"},
38390 : { (char *)"_gpgme_tofu_info_encrfirst_get", _wrap__gpgme_tofu_info_encrfirst_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrfirst_get(self) -> unsigned long"},
38391 : { (char *)"_gpgme_tofu_info_encrlast_set", _wrap__gpgme_tofu_info_encrlast_set, METH_VARARGS, (char *)"_gpgme_tofu_info_encrlast_set(self, encrlast)"},
38392 : { (char *)"_gpgme_tofu_info_encrlast_get", _wrap__gpgme_tofu_info_encrlast_get, METH_VARARGS, (char *)"_gpgme_tofu_info_encrlast_get(self) -> unsigned long"},
38393 : { (char *)"_gpgme_tofu_info_description_set", _wrap__gpgme_tofu_info_description_set, METH_VARARGS, (char *)"_gpgme_tofu_info_description_set(self, description)"},
38394 : { (char *)"_gpgme_tofu_info_description_get", _wrap__gpgme_tofu_info_description_get, METH_VARARGS, (char *)"_gpgme_tofu_info_description_get(self) -> char *"},
38395 : { (char *)"new__gpgme_tofu_info", _wrap_new__gpgme_tofu_info, METH_VARARGS, (char *)"new__gpgme_tofu_info() -> _gpgme_tofu_info"},
38396 : { (char *)"delete__gpgme_tofu_info", _wrap_delete__gpgme_tofu_info, METH_VARARGS, (char *)"delete__gpgme_tofu_info(self)"},
38397 : { (char *)"_gpgme_tofu_info_swigregister", _gpgme_tofu_info_swigregister, METH_VARARGS, NULL},
38398 : { (char *)"_gpgme_subkey_revoked_set", _wrap__gpgme_subkey_revoked_set, METH_VARARGS, (char *)"_gpgme_subkey_revoked_set(self, revoked)"},
38399 : { (char *)"_gpgme_subkey_revoked_get", _wrap__gpgme_subkey_revoked_get, METH_VARARGS, (char *)"_gpgme_subkey_revoked_get(self) -> unsigned int"},
38400 : { (char *)"_gpgme_subkey_expired_set", _wrap__gpgme_subkey_expired_set, METH_VARARGS, (char *)"_gpgme_subkey_expired_set(self, expired)"},
38401 : { (char *)"_gpgme_subkey_expired_get", _wrap__gpgme_subkey_expired_get, METH_VARARGS, (char *)"_gpgme_subkey_expired_get(self) -> unsigned int"},
38402 : { (char *)"_gpgme_subkey_disabled_set", _wrap__gpgme_subkey_disabled_set, METH_VARARGS, (char *)"_gpgme_subkey_disabled_set(self, disabled)"},
38403 : { (char *)"_gpgme_subkey_disabled_get", _wrap__gpgme_subkey_disabled_get, METH_VARARGS, (char *)"_gpgme_subkey_disabled_get(self) -> unsigned int"},
38404 : { (char *)"_gpgme_subkey_invalid_set", _wrap__gpgme_subkey_invalid_set, METH_VARARGS, (char *)"_gpgme_subkey_invalid_set(self, invalid)"},
38405 : { (char *)"_gpgme_subkey_invalid_get", _wrap__gpgme_subkey_invalid_get, METH_VARARGS, (char *)"_gpgme_subkey_invalid_get(self) -> unsigned int"},
38406 : { (char *)"_gpgme_subkey_can_encrypt_set", _wrap__gpgme_subkey_can_encrypt_set, METH_VARARGS, (char *)"_gpgme_subkey_can_encrypt_set(self, can_encrypt)"},
38407 : { (char *)"_gpgme_subkey_can_encrypt_get", _wrap__gpgme_subkey_can_encrypt_get, METH_VARARGS, (char *)"_gpgme_subkey_can_encrypt_get(self) -> unsigned int"},
38408 : { (char *)"_gpgme_subkey_can_sign_set", _wrap__gpgme_subkey_can_sign_set, METH_VARARGS, (char *)"_gpgme_subkey_can_sign_set(self, can_sign)"},
38409 : { (char *)"_gpgme_subkey_can_sign_get", _wrap__gpgme_subkey_can_sign_get, METH_VARARGS, (char *)"_gpgme_subkey_can_sign_get(self) -> unsigned int"},
38410 : { (char *)"_gpgme_subkey_can_certify_set", _wrap__gpgme_subkey_can_certify_set, METH_VARARGS, (char *)"_gpgme_subkey_can_certify_set(self, can_certify)"},
38411 : { (char *)"_gpgme_subkey_can_certify_get", _wrap__gpgme_subkey_can_certify_get, METH_VARARGS, (char *)"_gpgme_subkey_can_certify_get(self) -> unsigned int"},
38412 : { (char *)"_gpgme_subkey_secret_set", _wrap__gpgme_subkey_secret_set, METH_VARARGS, (char *)"_gpgme_subkey_secret_set(self, secret)"},
38413 : { (char *)"_gpgme_subkey_secret_get", _wrap__gpgme_subkey_secret_get, METH_VARARGS, (char *)"_gpgme_subkey_secret_get(self) -> unsigned int"},
38414 : { (char *)"_gpgme_subkey_can_authenticate_set", _wrap__gpgme_subkey_can_authenticate_set, METH_VARARGS, (char *)"_gpgme_subkey_can_authenticate_set(self, can_authenticate)"},
38415 : { (char *)"_gpgme_subkey_can_authenticate_get", _wrap__gpgme_subkey_can_authenticate_get, METH_VARARGS, (char *)"_gpgme_subkey_can_authenticate_get(self) -> unsigned int"},
38416 : { (char *)"_gpgme_subkey_is_qualified_set", _wrap__gpgme_subkey_is_qualified_set, METH_VARARGS, (char *)"_gpgme_subkey_is_qualified_set(self, is_qualified)"},
38417 : { (char *)"_gpgme_subkey_is_qualified_get", _wrap__gpgme_subkey_is_qualified_get, METH_VARARGS, (char *)"_gpgme_subkey_is_qualified_get(self) -> unsigned int"},
38418 : { (char *)"_gpgme_subkey_is_cardkey_set", _wrap__gpgme_subkey_is_cardkey_set, METH_VARARGS, (char *)"_gpgme_subkey_is_cardkey_set(self, is_cardkey)"},
38419 : { (char *)"_gpgme_subkey_is_cardkey_get", _wrap__gpgme_subkey_is_cardkey_get, METH_VARARGS, (char *)"_gpgme_subkey_is_cardkey_get(self) -> unsigned int"},
38420 : { (char *)"_gpgme_subkey__unused_set", _wrap__gpgme_subkey__unused_set, METH_VARARGS, (char *)"_gpgme_subkey__unused_set(self, _unused)"},
38421 : { (char *)"_gpgme_subkey__unused_get", _wrap__gpgme_subkey__unused_get, METH_VARARGS, (char *)"_gpgme_subkey__unused_get(self) -> unsigned int"},
38422 : { (char *)"_gpgme_subkey_pubkey_algo_set", _wrap__gpgme_subkey_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_subkey_pubkey_algo_set(self, pubkey_algo)"},
38423 : { (char *)"_gpgme_subkey_pubkey_algo_get", _wrap__gpgme_subkey_pubkey_algo_get, METH_VARARGS, (char *)"_gpgme_subkey_pubkey_algo_get(self) -> gpgme_pubkey_algo_t"},
38424 : { (char *)"_gpgme_subkey_length_set", _wrap__gpgme_subkey_length_set, METH_VARARGS, (char *)"_gpgme_subkey_length_set(self, length)"},
38425 : { (char *)"_gpgme_subkey_length_get", _wrap__gpgme_subkey_length_get, METH_VARARGS, (char *)"_gpgme_subkey_length_get(self) -> unsigned int"},
38426 : { (char *)"_gpgme_subkey_keyid_set", _wrap__gpgme_subkey_keyid_set, METH_VARARGS, (char *)"_gpgme_subkey_keyid_set(self, keyid)"},
38427 : { (char *)"_gpgme_subkey_keyid_get", _wrap__gpgme_subkey_keyid_get, METH_VARARGS, (char *)"_gpgme_subkey_keyid_get(self) -> char *"},
38428 : { (char *)"_gpgme_subkey__keyid_set", _wrap__gpgme_subkey__keyid_set, METH_VARARGS, (char *)"_gpgme_subkey__keyid_set(self, _keyid)"},
38429 : { (char *)"_gpgme_subkey__keyid_get", _wrap__gpgme_subkey__keyid_get, METH_VARARGS, (char *)"_gpgme_subkey__keyid_get(self) -> char [16+1]"},
38430 : { (char *)"_gpgme_subkey_fpr_set", _wrap__gpgme_subkey_fpr_set, METH_VARARGS, (char *)"_gpgme_subkey_fpr_set(self, fpr)"},
38431 : { (char *)"_gpgme_subkey_fpr_get", _wrap__gpgme_subkey_fpr_get, METH_VARARGS, (char *)"_gpgme_subkey_fpr_get(self) -> char *"},
38432 : { (char *)"_gpgme_subkey_timestamp_set", _wrap__gpgme_subkey_timestamp_set, METH_VARARGS, (char *)"_gpgme_subkey_timestamp_set(self, timestamp)"},
38433 : { (char *)"_gpgme_subkey_timestamp_get", _wrap__gpgme_subkey_timestamp_get, METH_VARARGS, (char *)"_gpgme_subkey_timestamp_get(self) -> long"},
38434 : { (char *)"_gpgme_subkey_expires_set", _wrap__gpgme_subkey_expires_set, METH_VARARGS, (char *)"_gpgme_subkey_expires_set(self, expires)"},
38435 : { (char *)"_gpgme_subkey_expires_get", _wrap__gpgme_subkey_expires_get, METH_VARARGS, (char *)"_gpgme_subkey_expires_get(self) -> long"},
38436 : { (char *)"_gpgme_subkey_card_number_set", _wrap__gpgme_subkey_card_number_set, METH_VARARGS, (char *)"_gpgme_subkey_card_number_set(self, card_number)"},
38437 : { (char *)"_gpgme_subkey_card_number_get", _wrap__gpgme_subkey_card_number_get, METH_VARARGS, (char *)"_gpgme_subkey_card_number_get(self) -> char *"},
38438 : { (char *)"_gpgme_subkey_curve_set", _wrap__gpgme_subkey_curve_set, METH_VARARGS, (char *)"_gpgme_subkey_curve_set(self, curve)"},
38439 : { (char *)"_gpgme_subkey_curve_get", _wrap__gpgme_subkey_curve_get, METH_VARARGS, (char *)"_gpgme_subkey_curve_get(self) -> char *"},
38440 : { (char *)"_gpgme_subkey_keygrip_set", _wrap__gpgme_subkey_keygrip_set, METH_VARARGS, (char *)"_gpgme_subkey_keygrip_set(self, keygrip)"},
38441 : { (char *)"_gpgme_subkey_keygrip_get", _wrap__gpgme_subkey_keygrip_get, METH_VARARGS, (char *)"_gpgme_subkey_keygrip_get(self) -> char *"},
38442 : { (char *)"new__gpgme_subkey", _wrap_new__gpgme_subkey, METH_VARARGS, (char *)"new__gpgme_subkey() -> _gpgme_subkey"},
38443 : { (char *)"delete__gpgme_subkey", _wrap_delete__gpgme_subkey, METH_VARARGS, (char *)"delete__gpgme_subkey(self)"},
38444 : { (char *)"_gpgme_subkey_swigregister", _gpgme_subkey_swigregister, METH_VARARGS, NULL},
38445 : { (char *)"_gpgme_key_sig_revoked_set", _wrap__gpgme_key_sig_revoked_set, METH_VARARGS, (char *)"_gpgme_key_sig_revoked_set(self, revoked)"},
38446 : { (char *)"_gpgme_key_sig_revoked_get", _wrap__gpgme_key_sig_revoked_get, METH_VARARGS, (char *)"_gpgme_key_sig_revoked_get(self) -> unsigned int"},
38447 : { (char *)"_gpgme_key_sig_expired_set", _wrap__gpgme_key_sig_expired_set, METH_VARARGS, (char *)"_gpgme_key_sig_expired_set(self, expired)"},
38448 : { (char *)"_gpgme_key_sig_expired_get", _wrap__gpgme_key_sig_expired_get, METH_VARARGS, (char *)"_gpgme_key_sig_expired_get(self) -> unsigned int"},
38449 : { (char *)"_gpgme_key_sig_invalid_set", _wrap__gpgme_key_sig_invalid_set, METH_VARARGS, (char *)"_gpgme_key_sig_invalid_set(self, invalid)"},
38450 : { (char *)"_gpgme_key_sig_invalid_get", _wrap__gpgme_key_sig_invalid_get, METH_VARARGS, (char *)"_gpgme_key_sig_invalid_get(self) -> unsigned int"},
38451 : { (char *)"_gpgme_key_sig_exportable_set", _wrap__gpgme_key_sig_exportable_set, METH_VARARGS, (char *)"_gpgme_key_sig_exportable_set(self, exportable)"},
38452 : { (char *)"_gpgme_key_sig_exportable_get", _wrap__gpgme_key_sig_exportable_get, METH_VARARGS, (char *)"_gpgme_key_sig_exportable_get(self) -> unsigned int"},
38453 : { (char *)"_gpgme_key_sig__unused_set", _wrap__gpgme_key_sig__unused_set, METH_VARARGS, (char *)"_gpgme_key_sig__unused_set(self, _unused)"},
38454 : { (char *)"_gpgme_key_sig__unused_get", _wrap__gpgme_key_sig__unused_get, METH_VARARGS, (char *)"_gpgme_key_sig__unused_get(self) -> unsigned int"},
38455 : { (char *)"_gpgme_key_sig_pubkey_algo_set", _wrap__gpgme_key_sig_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_key_sig_pubkey_algo_set(self, pubkey_algo)"},
38456 : { (char *)"_gpgme_key_sig_pubkey_algo_get", _wrap__gpgme_key_sig_pubkey_algo_get, METH_VARARGS, (char *)"_gpgme_key_sig_pubkey_algo_get(self) -> gpgme_pubkey_algo_t"},
38457 : { (char *)"_gpgme_key_sig_keyid_set", _wrap__gpgme_key_sig_keyid_set, METH_VARARGS, (char *)"_gpgme_key_sig_keyid_set(self, keyid)"},
38458 : { (char *)"_gpgme_key_sig_keyid_get", _wrap__gpgme_key_sig_keyid_get, METH_VARARGS, (char *)"_gpgme_key_sig_keyid_get(self) -> char *"},
38459 : { (char *)"_gpgme_key_sig__keyid_set", _wrap__gpgme_key_sig__keyid_set, METH_VARARGS, (char *)"_gpgme_key_sig__keyid_set(self, _keyid)"},
38460 : { (char *)"_gpgme_key_sig__keyid_get", _wrap__gpgme_key_sig__keyid_get, METH_VARARGS, (char *)"_gpgme_key_sig__keyid_get(self) -> char [16+1]"},
38461 : { (char *)"_gpgme_key_sig_timestamp_set", _wrap__gpgme_key_sig_timestamp_set, METH_VARARGS, (char *)"_gpgme_key_sig_timestamp_set(self, timestamp)"},
38462 : { (char *)"_gpgme_key_sig_timestamp_get", _wrap__gpgme_key_sig_timestamp_get, METH_VARARGS, (char *)"_gpgme_key_sig_timestamp_get(self) -> long"},
38463 : { (char *)"_gpgme_key_sig_expires_set", _wrap__gpgme_key_sig_expires_set, METH_VARARGS, (char *)"_gpgme_key_sig_expires_set(self, expires)"},
38464 : { (char *)"_gpgme_key_sig_expires_get", _wrap__gpgme_key_sig_expires_get, METH_VARARGS, (char *)"_gpgme_key_sig_expires_get(self) -> long"},
38465 : { (char *)"_gpgme_key_sig_status_set", _wrap__gpgme_key_sig_status_set, METH_VARARGS, (char *)"_gpgme_key_sig_status_set(self, status)"},
38466 : { (char *)"_gpgme_key_sig_status_get", _wrap__gpgme_key_sig_status_get, METH_VARARGS, (char *)"_gpgme_key_sig_status_get(self) -> gpgme_error_t"},
38467 : { (char *)"_gpgme_key_sig_uid_set", _wrap__gpgme_key_sig_uid_set, METH_VARARGS, (char *)"_gpgme_key_sig_uid_set(self, uid)"},
38468 : { (char *)"_gpgme_key_sig_uid_get", _wrap__gpgme_key_sig_uid_get, METH_VARARGS, (char *)"_gpgme_key_sig_uid_get(self) -> char *"},
38469 : { (char *)"_gpgme_key_sig_name_set", _wrap__gpgme_key_sig_name_set, METH_VARARGS, (char *)"_gpgme_key_sig_name_set(self, name)"},
38470 : { (char *)"_gpgme_key_sig_name_get", _wrap__gpgme_key_sig_name_get, METH_VARARGS, (char *)"_gpgme_key_sig_name_get(self) -> char *"},
38471 : { (char *)"_gpgme_key_sig_email_set", _wrap__gpgme_key_sig_email_set, METH_VARARGS, (char *)"_gpgme_key_sig_email_set(self, email)"},
38472 : { (char *)"_gpgme_key_sig_email_get", _wrap__gpgme_key_sig_email_get, METH_VARARGS, (char *)"_gpgme_key_sig_email_get(self) -> char *"},
38473 : { (char *)"_gpgme_key_sig_comment_set", _wrap__gpgme_key_sig_comment_set, METH_VARARGS, (char *)"_gpgme_key_sig_comment_set(self, comment)"},
38474 : { (char *)"_gpgme_key_sig_comment_get", _wrap__gpgme_key_sig_comment_get, METH_VARARGS, (char *)"_gpgme_key_sig_comment_get(self) -> char *"},
38475 : { (char *)"_gpgme_key_sig_sig_class_set", _wrap__gpgme_key_sig_sig_class_set, METH_VARARGS, (char *)"_gpgme_key_sig_sig_class_set(self, sig_class)"},
38476 : { (char *)"_gpgme_key_sig_sig_class_get", _wrap__gpgme_key_sig_sig_class_get, METH_VARARGS, (char *)"_gpgme_key_sig_sig_class_get(self) -> unsigned int"},
38477 : { (char *)"_gpgme_key_sig_notations_set", _wrap__gpgme_key_sig_notations_set, METH_VARARGS, (char *)"_gpgme_key_sig_notations_set(self, notations)"},
38478 : { (char *)"_gpgme_key_sig_notations_get", _wrap__gpgme_key_sig_notations_get, METH_VARARGS, (char *)"_gpgme_key_sig_notations_get(self) -> _gpgme_sig_notation"},
38479 : { (char *)"_gpgme_key_sig__last_notation_set", _wrap__gpgme_key_sig__last_notation_set, METH_VARARGS, (char *)"_gpgme_key_sig__last_notation_set(self, _last_notation)"},
38480 : { (char *)"_gpgme_key_sig__last_notation_get", _wrap__gpgme_key_sig__last_notation_get, METH_VARARGS, (char *)"_gpgme_key_sig__last_notation_get(self) -> _gpgme_sig_notation"},
38481 : { (char *)"new__gpgme_key_sig", _wrap_new__gpgme_key_sig, METH_VARARGS, (char *)"new__gpgme_key_sig() -> _gpgme_key_sig"},
38482 : { (char *)"delete__gpgme_key_sig", _wrap_delete__gpgme_key_sig, METH_VARARGS, (char *)"delete__gpgme_key_sig(self)"},
38483 : { (char *)"_gpgme_key_sig_swigregister", _gpgme_key_sig_swigregister, METH_VARARGS, NULL},
38484 : { (char *)"_gpgme_user_id_revoked_set", _wrap__gpgme_user_id_revoked_set, METH_VARARGS, (char *)"_gpgme_user_id_revoked_set(self, revoked)"},
38485 : { (char *)"_gpgme_user_id_revoked_get", _wrap__gpgme_user_id_revoked_get, METH_VARARGS, (char *)"_gpgme_user_id_revoked_get(self) -> unsigned int"},
38486 : { (char *)"_gpgme_user_id_invalid_set", _wrap__gpgme_user_id_invalid_set, METH_VARARGS, (char *)"_gpgme_user_id_invalid_set(self, invalid)"},
38487 : { (char *)"_gpgme_user_id_invalid_get", _wrap__gpgme_user_id_invalid_get, METH_VARARGS, (char *)"_gpgme_user_id_invalid_get(self) -> unsigned int"},
38488 : { (char *)"_gpgme_user_id__unused_set", _wrap__gpgme_user_id__unused_set, METH_VARARGS, (char *)"_gpgme_user_id__unused_set(self, _unused)"},
38489 : { (char *)"_gpgme_user_id__unused_get", _wrap__gpgme_user_id__unused_get, METH_VARARGS, (char *)"_gpgme_user_id__unused_get(self) -> unsigned int"},
38490 : { (char *)"_gpgme_user_id_validity_set", _wrap__gpgme_user_id_validity_set, METH_VARARGS, (char *)"_gpgme_user_id_validity_set(self, validity)"},
38491 : { (char *)"_gpgme_user_id_validity_get", _wrap__gpgme_user_id_validity_get, METH_VARARGS, (char *)"_gpgme_user_id_validity_get(self) -> gpgme_validity_t"},
38492 : { (char *)"_gpgme_user_id_uid_set", _wrap__gpgme_user_id_uid_set, METH_VARARGS, (char *)"_gpgme_user_id_uid_set(self, uid)"},
38493 : { (char *)"_gpgme_user_id_uid_get", _wrap__gpgme_user_id_uid_get, METH_VARARGS, (char *)"_gpgme_user_id_uid_get(self) -> char *"},
38494 : { (char *)"_gpgme_user_id_name_set", _wrap__gpgme_user_id_name_set, METH_VARARGS, (char *)"_gpgme_user_id_name_set(self, name)"},
38495 : { (char *)"_gpgme_user_id_name_get", _wrap__gpgme_user_id_name_get, METH_VARARGS, (char *)"_gpgme_user_id_name_get(self) -> char *"},
38496 : { (char *)"_gpgme_user_id_email_set", _wrap__gpgme_user_id_email_set, METH_VARARGS, (char *)"_gpgme_user_id_email_set(self, email)"},
38497 : { (char *)"_gpgme_user_id_email_get", _wrap__gpgme_user_id_email_get, METH_VARARGS, (char *)"_gpgme_user_id_email_get(self) -> char *"},
38498 : { (char *)"_gpgme_user_id_comment_set", _wrap__gpgme_user_id_comment_set, METH_VARARGS, (char *)"_gpgme_user_id_comment_set(self, comment)"},
38499 : { (char *)"_gpgme_user_id_comment_get", _wrap__gpgme_user_id_comment_get, METH_VARARGS, (char *)"_gpgme_user_id_comment_get(self) -> char *"},
38500 : { (char *)"_gpgme_user_id_signatures_set", _wrap__gpgme_user_id_signatures_set, METH_VARARGS, (char *)"_gpgme_user_id_signatures_set(self, signatures)"},
38501 : { (char *)"_gpgme_user_id_signatures_get", _wrap__gpgme_user_id_signatures_get, METH_VARARGS, (char *)"_gpgme_user_id_signatures_get(self) -> _gpgme_key_sig"},
38502 : { (char *)"_gpgme_user_id__last_keysig_set", _wrap__gpgme_user_id__last_keysig_set, METH_VARARGS, (char *)"_gpgme_user_id__last_keysig_set(self, _last_keysig)"},
38503 : { (char *)"_gpgme_user_id__last_keysig_get", _wrap__gpgme_user_id__last_keysig_get, METH_VARARGS, (char *)"_gpgme_user_id__last_keysig_get(self) -> _gpgme_key_sig"},
38504 : { (char *)"_gpgme_user_id_address_set", _wrap__gpgme_user_id_address_set, METH_VARARGS, (char *)"_gpgme_user_id_address_set(self, address)"},
38505 : { (char *)"_gpgme_user_id_address_get", _wrap__gpgme_user_id_address_get, METH_VARARGS, (char *)"_gpgme_user_id_address_get(self) -> char *"},
38506 : { (char *)"_gpgme_user_id_tofu_set", _wrap__gpgme_user_id_tofu_set, METH_VARARGS, (char *)"_gpgme_user_id_tofu_set(self, tofu)"},
38507 : { (char *)"_gpgme_user_id_tofu_get", _wrap__gpgme_user_id_tofu_get, METH_VARARGS, (char *)"_gpgme_user_id_tofu_get(self) -> _gpgme_tofu_info"},
38508 : { (char *)"new__gpgme_user_id", _wrap_new__gpgme_user_id, METH_VARARGS, (char *)"new__gpgme_user_id() -> _gpgme_user_id"},
38509 : { (char *)"delete__gpgme_user_id", _wrap_delete__gpgme_user_id, METH_VARARGS, (char *)"delete__gpgme_user_id(self)"},
38510 : { (char *)"_gpgme_user_id_swigregister", _gpgme_user_id_swigregister, METH_VARARGS, NULL},
38511 : { (char *)"_gpgme_key__refs_set", _wrap__gpgme_key__refs_set, METH_VARARGS, (char *)"_gpgme_key__refs_set(self, _refs)"},
38512 : { (char *)"_gpgme_key__refs_get", _wrap__gpgme_key__refs_get, METH_VARARGS, (char *)"_gpgme_key__refs_get(self) -> unsigned int"},
38513 : { (char *)"_gpgme_key_revoked_set", _wrap__gpgme_key_revoked_set, METH_VARARGS, (char *)"_gpgme_key_revoked_set(self, revoked)"},
38514 : { (char *)"_gpgme_key_revoked_get", _wrap__gpgme_key_revoked_get, METH_VARARGS, (char *)"_gpgme_key_revoked_get(self) -> unsigned int"},
38515 : { (char *)"_gpgme_key_expired_set", _wrap__gpgme_key_expired_set, METH_VARARGS, (char *)"_gpgme_key_expired_set(self, expired)"},
38516 : { (char *)"_gpgme_key_expired_get", _wrap__gpgme_key_expired_get, METH_VARARGS, (char *)"_gpgme_key_expired_get(self) -> unsigned int"},
38517 : { (char *)"_gpgme_key_disabled_set", _wrap__gpgme_key_disabled_set, METH_VARARGS, (char *)"_gpgme_key_disabled_set(self, disabled)"},
38518 : { (char *)"_gpgme_key_disabled_get", _wrap__gpgme_key_disabled_get, METH_VARARGS, (char *)"_gpgme_key_disabled_get(self) -> unsigned int"},
38519 : { (char *)"_gpgme_key_invalid_set", _wrap__gpgme_key_invalid_set, METH_VARARGS, (char *)"_gpgme_key_invalid_set(self, invalid)"},
38520 : { (char *)"_gpgme_key_invalid_get", _wrap__gpgme_key_invalid_get, METH_VARARGS, (char *)"_gpgme_key_invalid_get(self) -> unsigned int"},
38521 : { (char *)"_gpgme_key_can_encrypt_set", _wrap__gpgme_key_can_encrypt_set, METH_VARARGS, (char *)"_gpgme_key_can_encrypt_set(self, can_encrypt)"},
38522 : { (char *)"_gpgme_key_can_encrypt_get", _wrap__gpgme_key_can_encrypt_get, METH_VARARGS, (char *)"_gpgme_key_can_encrypt_get(self) -> unsigned int"},
38523 : { (char *)"_gpgme_key_can_sign_set", _wrap__gpgme_key_can_sign_set, METH_VARARGS, (char *)"_gpgme_key_can_sign_set(self, can_sign)"},
38524 : { (char *)"_gpgme_key_can_sign_get", _wrap__gpgme_key_can_sign_get, METH_VARARGS, (char *)"_gpgme_key_can_sign_get(self) -> unsigned int"},
38525 : { (char *)"_gpgme_key_can_certify_set", _wrap__gpgme_key_can_certify_set, METH_VARARGS, (char *)"_gpgme_key_can_certify_set(self, can_certify)"},
38526 : { (char *)"_gpgme_key_can_certify_get", _wrap__gpgme_key_can_certify_get, METH_VARARGS, (char *)"_gpgme_key_can_certify_get(self) -> unsigned int"},
38527 : { (char *)"_gpgme_key_secret_set", _wrap__gpgme_key_secret_set, METH_VARARGS, (char *)"_gpgme_key_secret_set(self, secret)"},
38528 : { (char *)"_gpgme_key_secret_get", _wrap__gpgme_key_secret_get, METH_VARARGS, (char *)"_gpgme_key_secret_get(self) -> unsigned int"},
38529 : { (char *)"_gpgme_key_can_authenticate_set", _wrap__gpgme_key_can_authenticate_set, METH_VARARGS, (char *)"_gpgme_key_can_authenticate_set(self, can_authenticate)"},
38530 : { (char *)"_gpgme_key_can_authenticate_get", _wrap__gpgme_key_can_authenticate_get, METH_VARARGS, (char *)"_gpgme_key_can_authenticate_get(self) -> unsigned int"},
38531 : { (char *)"_gpgme_key_is_qualified_set", _wrap__gpgme_key_is_qualified_set, METH_VARARGS, (char *)"_gpgme_key_is_qualified_set(self, is_qualified)"},
38532 : { (char *)"_gpgme_key_is_qualified_get", _wrap__gpgme_key_is_qualified_get, METH_VARARGS, (char *)"_gpgme_key_is_qualified_get(self) -> unsigned int"},
38533 : { (char *)"_gpgme_key__unused_set", _wrap__gpgme_key__unused_set, METH_VARARGS, (char *)"_gpgme_key__unused_set(self, _unused)"},
38534 : { (char *)"_gpgme_key__unused_get", _wrap__gpgme_key__unused_get, METH_VARARGS, (char *)"_gpgme_key__unused_get(self) -> unsigned int"},
38535 : { (char *)"_gpgme_key_protocol_set", _wrap__gpgme_key_protocol_set, METH_VARARGS, (char *)"_gpgme_key_protocol_set(self, protocol)"},
38536 : { (char *)"_gpgme_key_protocol_get", _wrap__gpgme_key_protocol_get, METH_VARARGS, (char *)"_gpgme_key_protocol_get(self) -> gpgme_protocol_t"},
38537 : { (char *)"_gpgme_key_issuer_serial_set", _wrap__gpgme_key_issuer_serial_set, METH_VARARGS, (char *)"_gpgme_key_issuer_serial_set(self, issuer_serial)"},
38538 : { (char *)"_gpgme_key_issuer_serial_get", _wrap__gpgme_key_issuer_serial_get, METH_VARARGS, (char *)"_gpgme_key_issuer_serial_get(self) -> char *"},
38539 : { (char *)"_gpgme_key_issuer_name_set", _wrap__gpgme_key_issuer_name_set, METH_VARARGS, (char *)"_gpgme_key_issuer_name_set(self, issuer_name)"},
38540 : { (char *)"_gpgme_key_issuer_name_get", _wrap__gpgme_key_issuer_name_get, METH_VARARGS, (char *)"_gpgme_key_issuer_name_get(self) -> char *"},
38541 : { (char *)"_gpgme_key_chain_id_set", _wrap__gpgme_key_chain_id_set, METH_VARARGS, (char *)"_gpgme_key_chain_id_set(self, chain_id)"},
38542 : { (char *)"_gpgme_key_chain_id_get", _wrap__gpgme_key_chain_id_get, METH_VARARGS, (char *)"_gpgme_key_chain_id_get(self) -> char *"},
38543 : { (char *)"_gpgme_key_owner_trust_set", _wrap__gpgme_key_owner_trust_set, METH_VARARGS, (char *)"_gpgme_key_owner_trust_set(self, owner_trust)"},
38544 : { (char *)"_gpgme_key_owner_trust_get", _wrap__gpgme_key_owner_trust_get, METH_VARARGS, (char *)"_gpgme_key_owner_trust_get(self) -> gpgme_validity_t"},
38545 : { (char *)"_gpgme_key_subkeys_set", _wrap__gpgme_key_subkeys_set, METH_VARARGS, (char *)"_gpgme_key_subkeys_set(self, subkeys)"},
38546 : { (char *)"_gpgme_key_subkeys_get", _wrap__gpgme_key_subkeys_get, METH_VARARGS, (char *)"_gpgme_key_subkeys_get(self) -> _gpgme_subkey"},
38547 : { (char *)"_gpgme_key_uids_set", _wrap__gpgme_key_uids_set, METH_VARARGS, (char *)"_gpgme_key_uids_set(self, uids)"},
38548 : { (char *)"_gpgme_key_uids_get", _wrap__gpgme_key_uids_get, METH_VARARGS, (char *)"_gpgme_key_uids_get(self) -> _gpgme_user_id"},
38549 : { (char *)"_gpgme_key__last_subkey_set", _wrap__gpgme_key__last_subkey_set, METH_VARARGS, (char *)"_gpgme_key__last_subkey_set(self, _last_subkey)"},
38550 : { (char *)"_gpgme_key__last_subkey_get", _wrap__gpgme_key__last_subkey_get, METH_VARARGS, (char *)"_gpgme_key__last_subkey_get(self) -> _gpgme_subkey"},
38551 : { (char *)"_gpgme_key__last_uid_set", _wrap__gpgme_key__last_uid_set, METH_VARARGS, (char *)"_gpgme_key__last_uid_set(self, _last_uid)"},
38552 : { (char *)"_gpgme_key__last_uid_get", _wrap__gpgme_key__last_uid_get, METH_VARARGS, (char *)"_gpgme_key__last_uid_get(self) -> _gpgme_user_id"},
38553 : { (char *)"_gpgme_key_keylist_mode_set", _wrap__gpgme_key_keylist_mode_set, METH_VARARGS, (char *)"_gpgme_key_keylist_mode_set(self, keylist_mode)"},
38554 : { (char *)"_gpgme_key_keylist_mode_get", _wrap__gpgme_key_keylist_mode_get, METH_VARARGS, (char *)"_gpgme_key_keylist_mode_get(self) -> gpgme_keylist_mode_t"},
38555 : { (char *)"_gpgme_key_fpr_set", _wrap__gpgme_key_fpr_set, METH_VARARGS, (char *)"_gpgme_key_fpr_set(self, fpr)"},
38556 : { (char *)"_gpgme_key_fpr_get", _wrap__gpgme_key_fpr_get, METH_VARARGS, (char *)"_gpgme_key_fpr_get(self) -> char *"},
38557 : { (char *)"new__gpgme_key", _wrap_new__gpgme_key, METH_VARARGS, (char *)"new__gpgme_key() -> _gpgme_key"},
38558 : { (char *)"delete__gpgme_key", _wrap_delete__gpgme_key, METH_VARARGS, (char *)"delete__gpgme_key(self)"},
38559 : { (char *)"_gpgme_key_swigregister", _gpgme_key_swigregister, METH_VARARGS, NULL},
38560 : { (char *)"_gpgme_invalid_key_fpr_set", _wrap__gpgme_invalid_key_fpr_set, METH_VARARGS, (char *)"_gpgme_invalid_key_fpr_set(self, fpr)"},
38561 : { (char *)"_gpgme_invalid_key_fpr_get", _wrap__gpgme_invalid_key_fpr_get, METH_VARARGS, (char *)"_gpgme_invalid_key_fpr_get(self) -> char *"},
38562 : { (char *)"_gpgme_invalid_key_reason_set", _wrap__gpgme_invalid_key_reason_set, METH_VARARGS, (char *)"_gpgme_invalid_key_reason_set(self, reason)"},
38563 : { (char *)"_gpgme_invalid_key_reason_get", _wrap__gpgme_invalid_key_reason_get, METH_VARARGS, (char *)"_gpgme_invalid_key_reason_get(self) -> gpgme_error_t"},
38564 : { (char *)"new__gpgme_invalid_key", _wrap_new__gpgme_invalid_key, METH_VARARGS, (char *)"new__gpgme_invalid_key() -> _gpgme_invalid_key"},
38565 : { (char *)"delete__gpgme_invalid_key", _wrap_delete__gpgme_invalid_key, METH_VARARGS, (char *)"delete__gpgme_invalid_key(self)"},
38566 : { (char *)"_gpgme_invalid_key_swigregister", _gpgme_invalid_key_swigregister, METH_VARARGS, NULL},
38567 : { (char *)"gpgme_new", _wrap_gpgme_new, METH_VARARGS, (char *)"gpgme_new(ctx) -> gpgme_error_t"},
38568 : { (char *)"gpgme_release", _wrap_gpgme_release, METH_VARARGS, (char *)"gpgme_release(ctx)"},
38569 : { (char *)"gpgme_set_ctx_flag", _wrap_gpgme_set_ctx_flag, METH_VARARGS, (char *)"gpgme_set_ctx_flag(ctx, name, value) -> gpgme_error_t"},
38570 : { (char *)"gpgme_get_ctx_flag", _wrap_gpgme_get_ctx_flag, METH_VARARGS, (char *)"gpgme_get_ctx_flag(ctx, name) -> char const *"},
38571 : { (char *)"gpgme_set_protocol", _wrap_gpgme_set_protocol, METH_VARARGS, (char *)"gpgme_set_protocol(ctx, proto) -> gpgme_error_t"},
38572 : { (char *)"gpgme_get_protocol", _wrap_gpgme_get_protocol, METH_VARARGS, (char *)"gpgme_get_protocol(ctx) -> gpgme_protocol_t"},
38573 : { (char *)"gpgme_set_sub_protocol", _wrap_gpgme_set_sub_protocol, METH_VARARGS, (char *)"gpgme_set_sub_protocol(ctx, proto) -> gpgme_error_t"},
38574 : { (char *)"gpgme_get_sub_protocol", _wrap_gpgme_get_sub_protocol, METH_VARARGS, (char *)"gpgme_get_sub_protocol(ctx) -> gpgme_protocol_t"},
38575 : { (char *)"gpgme_get_protocol_name", _wrap_gpgme_get_protocol_name, METH_VARARGS, (char *)"gpgme_get_protocol_name(proto) -> char const *"},
38576 : { (char *)"gpgme_set_armor", _wrap_gpgme_set_armor, METH_VARARGS, (char *)"gpgme_set_armor(ctx, yes)"},
38577 : { (char *)"gpgme_get_armor", _wrap_gpgme_get_armor, METH_VARARGS, (char *)"gpgme_get_armor(ctx) -> int"},
38578 : { (char *)"gpgme_set_textmode", _wrap_gpgme_set_textmode, METH_VARARGS, (char *)"gpgme_set_textmode(ctx, yes)"},
38579 : { (char *)"gpgme_get_textmode", _wrap_gpgme_get_textmode, METH_VARARGS, (char *)"gpgme_get_textmode(ctx) -> int"},
38580 : { (char *)"gpgme_set_offline", _wrap_gpgme_set_offline, METH_VARARGS, (char *)"gpgme_set_offline(ctx, yes)"},
38581 : { (char *)"gpgme_get_offline", _wrap_gpgme_get_offline, METH_VARARGS, (char *)"gpgme_get_offline(ctx) -> int"},
38582 : { (char *)"gpgme_set_include_certs", _wrap_gpgme_set_include_certs, METH_VARARGS, (char *)"gpgme_set_include_certs(ctx, nr_of_certs)"},
38583 : { (char *)"gpgme_get_include_certs", _wrap_gpgme_get_include_certs, METH_VARARGS, (char *)"gpgme_get_include_certs(ctx) -> int"},
38584 : { (char *)"gpgme_set_keylist_mode", _wrap_gpgme_set_keylist_mode, METH_VARARGS, (char *)"gpgme_set_keylist_mode(ctx, mode) -> gpgme_error_t"},
38585 : { (char *)"gpgme_get_keylist_mode", _wrap_gpgme_get_keylist_mode, METH_VARARGS, (char *)"gpgme_get_keylist_mode(ctx) -> gpgme_keylist_mode_t"},
38586 : { (char *)"gpgme_set_pinentry_mode", _wrap_gpgme_set_pinentry_mode, METH_VARARGS, (char *)"gpgme_set_pinentry_mode(ctx, mode) -> gpgme_error_t"},
38587 : { (char *)"gpgme_get_pinentry_mode", _wrap_gpgme_get_pinentry_mode, METH_VARARGS, (char *)"gpgme_get_pinentry_mode(ctx) -> gpgme_pinentry_mode_t"},
38588 : { (char *)"gpgme_set_passphrase_cb", _wrap_gpgme_set_passphrase_cb, METH_VARARGS, (char *)"gpgme_set_passphrase_cb(ctx, cb, hook_value)"},
38589 : { (char *)"gpgme_get_passphrase_cb", _wrap_gpgme_get_passphrase_cb, METH_VARARGS, (char *)"gpgme_get_passphrase_cb(ctx, cb, hook_value)"},
38590 : { (char *)"gpgme_set_progress_cb", _wrap_gpgme_set_progress_cb, METH_VARARGS, (char *)"gpgme_set_progress_cb(c, cb, hook_value)"},
38591 : { (char *)"gpgme_get_progress_cb", _wrap_gpgme_get_progress_cb, METH_VARARGS, (char *)"gpgme_get_progress_cb(ctx, cb, hook_value)"},
38592 : { (char *)"gpgme_set_status_cb", _wrap_gpgme_set_status_cb, METH_VARARGS, (char *)"gpgme_set_status_cb(c, cb, hook_value)"},
38593 : { (char *)"gpgme_get_status_cb", _wrap_gpgme_get_status_cb, METH_VARARGS, (char *)"gpgme_get_status_cb(ctx, cb, hook_value)"},
38594 : { (char *)"gpgme_set_locale", _wrap_gpgme_set_locale, METH_VARARGS, (char *)"gpgme_set_locale(ctx, category, value) -> gpgme_error_t"},
38595 : { (char *)"gpgme_ctx_get_engine_info", _wrap_gpgme_ctx_get_engine_info, METH_VARARGS, (char *)"gpgme_ctx_get_engine_info(ctx) -> _gpgme_engine_info"},
38596 : { (char *)"gpgme_ctx_set_engine_info", _wrap_gpgme_ctx_set_engine_info, METH_VARARGS, (char *)"gpgme_ctx_set_engine_info(ctx, proto, file_name, home_dir) -> gpgme_error_t"},
38597 : { (char *)"gpgme_signers_clear", _wrap_gpgme_signers_clear, METH_VARARGS, (char *)"gpgme_signers_clear(ctx)"},
38598 : { (char *)"gpgme_signers_add", _wrap_gpgme_signers_add, METH_VARARGS, (char *)"gpgme_signers_add(ctx, key) -> gpgme_error_t"},
38599 : { (char *)"gpgme_signers_count", _wrap_gpgme_signers_count, METH_VARARGS, (char *)"gpgme_signers_count(ctx) -> unsigned int"},
38600 : { (char *)"gpgme_signers_enum", _wrap_gpgme_signers_enum, METH_VARARGS, (char *)"gpgme_signers_enum(ctx, seq) -> _gpgme_key"},
38601 : { (char *)"gpgme_sig_notation_clear", _wrap_gpgme_sig_notation_clear, METH_VARARGS, (char *)"gpgme_sig_notation_clear(ctx)"},
38602 : { (char *)"gpgme_sig_notation_add", _wrap_gpgme_sig_notation_add, METH_VARARGS, (char *)"gpgme_sig_notation_add(ctx, name, value, flags) -> gpgme_error_t"},
38603 : { (char *)"gpgme_sig_notation_get", _wrap_gpgme_sig_notation_get, METH_VARARGS, (char *)"gpgme_sig_notation_get(ctx) -> _gpgme_sig_notation"},
38604 : { (char *)"gpgme_set_sender", _wrap_gpgme_set_sender, METH_VARARGS, (char *)"gpgme_set_sender(ctx, address) -> gpgme_error_t"},
38605 : { (char *)"gpgme_get_sender", _wrap_gpgme_get_sender, METH_VARARGS, (char *)"gpgme_get_sender(ctx) -> char const *"},
38606 : { (char *)"gpgme_io_event_done_data_err_set", _wrap_gpgme_io_event_done_data_err_set, METH_VARARGS, (char *)"gpgme_io_event_done_data_err_set(self, err)"},
38607 : { (char *)"gpgme_io_event_done_data_err_get", _wrap_gpgme_io_event_done_data_err_get, METH_VARARGS, (char *)"gpgme_io_event_done_data_err_get(self) -> gpgme_error_t"},
38608 : { (char *)"gpgme_io_event_done_data_op_err_set", _wrap_gpgme_io_event_done_data_op_err_set, METH_VARARGS, (char *)"gpgme_io_event_done_data_op_err_set(self, op_err)"},
38609 : { (char *)"gpgme_io_event_done_data_op_err_get", _wrap_gpgme_io_event_done_data_op_err_get, METH_VARARGS, (char *)"gpgme_io_event_done_data_op_err_get(self) -> gpgme_error_t"},
38610 : { (char *)"new_gpgme_io_event_done_data", _wrap_new_gpgme_io_event_done_data, METH_VARARGS, (char *)"new_gpgme_io_event_done_data() -> gpgme_io_event_done_data"},
38611 : { (char *)"delete_gpgme_io_event_done_data", _wrap_delete_gpgme_io_event_done_data, METH_VARARGS, (char *)"delete_gpgme_io_event_done_data(self)"},
38612 : { (char *)"gpgme_io_event_done_data_swigregister", gpgme_io_event_done_data_swigregister, METH_VARARGS, NULL},
38613 : { (char *)"gpgme_io_cbs_add_set", _wrap_gpgme_io_cbs_add_set, METH_VARARGS, (char *)"gpgme_io_cbs_add_set(self, add)"},
38614 : { (char *)"gpgme_io_cbs_add_get", _wrap_gpgme_io_cbs_add_get, METH_VARARGS, (char *)"gpgme_io_cbs_add_get(self) -> gpgme_register_io_cb_t"},
38615 : { (char *)"gpgme_io_cbs_add_priv_set", _wrap_gpgme_io_cbs_add_priv_set, METH_VARARGS, (char *)"gpgme_io_cbs_add_priv_set(self, add_priv)"},
38616 : { (char *)"gpgme_io_cbs_add_priv_get", _wrap_gpgme_io_cbs_add_priv_get, METH_VARARGS, (char *)"gpgme_io_cbs_add_priv_get(self) -> void *"},
38617 : { (char *)"gpgme_io_cbs_remove_set", _wrap_gpgme_io_cbs_remove_set, METH_VARARGS, (char *)"gpgme_io_cbs_remove_set(self, remove)"},
38618 : { (char *)"gpgme_io_cbs_remove_get", _wrap_gpgme_io_cbs_remove_get, METH_VARARGS, (char *)"gpgme_io_cbs_remove_get(self) -> gpgme_remove_io_cb_t"},
38619 : { (char *)"gpgme_io_cbs_event_set", _wrap_gpgme_io_cbs_event_set, METH_VARARGS, (char *)"gpgme_io_cbs_event_set(self, event)"},
38620 : { (char *)"gpgme_io_cbs_event_get", _wrap_gpgme_io_cbs_event_get, METH_VARARGS, (char *)"gpgme_io_cbs_event_get(self) -> gpgme_event_io_cb_t"},
38621 : { (char *)"gpgme_io_cbs_event_priv_set", _wrap_gpgme_io_cbs_event_priv_set, METH_VARARGS, (char *)"gpgme_io_cbs_event_priv_set(self, event_priv)"},
38622 : { (char *)"gpgme_io_cbs_event_priv_get", _wrap_gpgme_io_cbs_event_priv_get, METH_VARARGS, (char *)"gpgme_io_cbs_event_priv_get(self) -> void *"},
38623 : { (char *)"new_gpgme_io_cbs", _wrap_new_gpgme_io_cbs, METH_VARARGS, (char *)"new_gpgme_io_cbs() -> gpgme_io_cbs"},
38624 : { (char *)"delete_gpgme_io_cbs", _wrap_delete_gpgme_io_cbs, METH_VARARGS, (char *)"delete_gpgme_io_cbs(self)"},
38625 : { (char *)"gpgme_io_cbs_swigregister", gpgme_io_cbs_swigregister, METH_VARARGS, NULL},
38626 : { (char *)"gpgme_set_io_cbs", _wrap_gpgme_set_io_cbs, METH_VARARGS, (char *)"gpgme_set_io_cbs(ctx, io_cbs)"},
38627 : { (char *)"gpgme_get_io_cbs", _wrap_gpgme_get_io_cbs, METH_VARARGS, (char *)"gpgme_get_io_cbs(ctx, io_cbs)"},
38628 : { (char *)"gpgme_io_read", _wrap_gpgme_io_read, METH_VARARGS, (char *)"gpgme_io_read(fd, buffer, count) -> ssize_t"},
38629 : { (char *)"gpgme_io_write", _wrap_gpgme_io_write, METH_VARARGS, (char *)"gpgme_io_write(fd, buffer, count) -> ssize_t"},
38630 : { (char *)"gpgme_io_writen", _wrap_gpgme_io_writen, METH_VARARGS, (char *)"gpgme_io_writen(fd, buffer, count) -> int"},
38631 : { (char *)"gpgme_wait", _wrap_gpgme_wait, METH_VARARGS, (char *)"gpgme_wait(ctx, status, hang) -> gpgme_ctx_t"},
38632 : { (char *)"gpgme_wait_ext", _wrap_gpgme_wait_ext, METH_VARARGS, (char *)"gpgme_wait_ext(ctx, status, op_err, hang) -> gpgme_ctx_t"},
38633 : { (char *)"gpgme_cancel", _wrap_gpgme_cancel, METH_VARARGS, (char *)"gpgme_cancel(ctx) -> gpgme_error_t"},
38634 : { (char *)"gpgme_cancel_async", _wrap_gpgme_cancel_async, METH_VARARGS, (char *)"gpgme_cancel_async(ctx) -> gpgme_error_t"},
38635 : { (char *)"gpgme_data_cbs_read_set", _wrap_gpgme_data_cbs_read_set, METH_VARARGS, (char *)"gpgme_data_cbs_read_set(self, read)"},
38636 : { (char *)"gpgme_data_cbs_read_get", _wrap_gpgme_data_cbs_read_get, METH_VARARGS, (char *)"gpgme_data_cbs_read_get(self) -> gpgme_data_read_cb_t"},
38637 : { (char *)"gpgme_data_cbs_write_set", _wrap_gpgme_data_cbs_write_set, METH_VARARGS, (char *)"gpgme_data_cbs_write_set(self, write)"},
38638 : { (char *)"gpgme_data_cbs_write_get", _wrap_gpgme_data_cbs_write_get, METH_VARARGS, (char *)"gpgme_data_cbs_write_get(self) -> gpgme_data_write_cb_t"},
38639 : { (char *)"gpgme_data_cbs_seek_set", _wrap_gpgme_data_cbs_seek_set, METH_VARARGS, (char *)"gpgme_data_cbs_seek_set(self, seek)"},
38640 : { (char *)"gpgme_data_cbs_seek_get", _wrap_gpgme_data_cbs_seek_get, METH_VARARGS, (char *)"gpgme_data_cbs_seek_get(self) -> gpgme_data_seek_cb_t"},
38641 : { (char *)"gpgme_data_cbs_release_set", _wrap_gpgme_data_cbs_release_set, METH_VARARGS, (char *)"gpgme_data_cbs_release_set(self, release)"},
38642 : { (char *)"gpgme_data_cbs_release_get", _wrap_gpgme_data_cbs_release_get, METH_VARARGS, (char *)"gpgme_data_cbs_release_get(self) -> gpgme_data_release_cb_t"},
38643 : { (char *)"new_gpgme_data_cbs", _wrap_new_gpgme_data_cbs, METH_VARARGS, (char *)"new_gpgme_data_cbs() -> gpgme_data_cbs"},
38644 : { (char *)"delete_gpgme_data_cbs", _wrap_delete_gpgme_data_cbs, METH_VARARGS, (char *)"delete_gpgme_data_cbs(self)"},
38645 : { (char *)"gpgme_data_cbs_swigregister", gpgme_data_cbs_swigregister, METH_VARARGS, NULL},
38646 : { (char *)"gpgme_data_read", _wrap_gpgme_data_read, METH_VARARGS, (char *)"gpgme_data_read(dh, buffer) -> ssize_t"},
38647 : { (char *)"gpgme_data_write", _wrap_gpgme_data_write, METH_VARARGS, (char *)"gpgme_data_write(dh, buffer) -> ssize_t"},
38648 : { (char *)"gpgme_data_seek", _wrap_gpgme_data_seek, METH_VARARGS, (char *)"gpgme_data_seek(dh, offset, whence) -> off_t"},
38649 : { (char *)"gpgme_data_new", _wrap_gpgme_data_new, METH_VARARGS, (char *)"gpgme_data_new(r_dh) -> gpgme_error_t"},
38650 : { (char *)"gpgme_data_release", _wrap_gpgme_data_release, METH_VARARGS, (char *)"gpgme_data_release(dh)"},
38651 : { (char *)"gpgme_data_new_from_mem", _wrap_gpgme_data_new_from_mem, METH_VARARGS, (char *)"gpgme_data_new_from_mem(r_dh, buffer, size, copy) -> gpgme_error_t"},
38652 : { (char *)"gpgme_data_release_and_get_mem", _wrap_gpgme_data_release_and_get_mem, METH_VARARGS, (char *)"gpgme_data_release_and_get_mem(dh, r_len) -> char *"},
38653 : { (char *)"gpgme_free", _wrap_gpgme_free, METH_VARARGS, (char *)"gpgme_free(buffer)"},
38654 : { (char *)"gpgme_data_new_from_cbs", _wrap_gpgme_data_new_from_cbs, METH_VARARGS, (char *)"gpgme_data_new_from_cbs(dh, cbs, handle) -> gpgme_error_t"},
38655 : { (char *)"gpgme_data_new_from_fd", _wrap_gpgme_data_new_from_fd, METH_VARARGS, (char *)"gpgme_data_new_from_fd(dh, fd) -> gpgme_error_t"},
38656 : { (char *)"gpgme_data_new_from_stream", _wrap_gpgme_data_new_from_stream, METH_VARARGS, (char *)"gpgme_data_new_from_stream(dh, stream) -> gpgme_error_t"},
38657 : { (char *)"gpgme_data_get_encoding", _wrap_gpgme_data_get_encoding, METH_VARARGS, (char *)"gpgme_data_get_encoding(dh) -> gpgme_data_encoding_t"},
38658 : { (char *)"gpgme_data_set_encoding", _wrap_gpgme_data_set_encoding, METH_VARARGS, (char *)"gpgme_data_set_encoding(dh, enc) -> gpgme_error_t"},
38659 : { (char *)"gpgme_data_get_file_name", _wrap_gpgme_data_get_file_name, METH_VARARGS, (char *)"gpgme_data_get_file_name(dh) -> char *"},
38660 : { (char *)"gpgme_data_set_file_name", _wrap_gpgme_data_set_file_name, METH_VARARGS, (char *)"gpgme_data_set_file_name(dh, file_name) -> gpgme_error_t"},
38661 : { (char *)"gpgme_data_set_flag", _wrap_gpgme_data_set_flag, METH_VARARGS, (char *)"gpgme_data_set_flag(dh, name, value) -> gpg_error_t"},
38662 : { (char *)"gpgme_data_identify", _wrap_gpgme_data_identify, METH_VARARGS, (char *)"gpgme_data_identify(dh, reserved) -> gpgme_data_type_t"},
38663 : { (char *)"gpgme_data_new_from_file", _wrap_gpgme_data_new_from_file, METH_VARARGS, (char *)"gpgme_data_new_from_file(r_dh, fname, copy) -> gpgme_error_t"},
38664 : { (char *)"gpgme_data_new_from_filepart", _wrap_gpgme_data_new_from_filepart, METH_VARARGS, (char *)"gpgme_data_new_from_filepart(r_dh, fname, fp, offset, length) -> gpgme_error_t"},
38665 : { (char *)"gpgme_data_rewind", _wrap_gpgme_data_rewind, METH_VARARGS, (char *)"gpgme_data_rewind(dh) -> gpgme_error_t"},
38666 : { (char *)"gpgme_get_key", _wrap_gpgme_get_key, METH_VARARGS, (char *)"gpgme_get_key(ctx, fpr, r_key, secret) -> gpgme_error_t"},
38667 : { (char *)"gpgme_key_from_uid", _wrap_gpgme_key_from_uid, METH_VARARGS, (char *)"gpgme_key_from_uid(key, name) -> gpgme_error_t"},
38668 : { (char *)"gpgme_key_ref", _wrap_gpgme_key_ref, METH_VARARGS, (char *)"gpgme_key_ref(key)"},
38669 : { (char *)"gpgme_key_unref", _wrap_gpgme_key_unref, METH_VARARGS, (char *)"gpgme_key_unref(key)"},
38670 : { (char *)"gpgme_key_release", _wrap_gpgme_key_release, METH_VARARGS, (char *)"gpgme_key_release(key)"},
38671 : { (char *)"_gpgme_op_encrypt_result_invalid_recipients_set", _wrap__gpgme_op_encrypt_result_invalid_recipients_set, METH_VARARGS, (char *)"_gpgme_op_encrypt_result_invalid_recipients_set(self, invalid_recipients)"},
38672 : { (char *)"_gpgme_op_encrypt_result_invalid_recipients_get", _wrap__gpgme_op_encrypt_result_invalid_recipients_get, METH_VARARGS, (char *)"_gpgme_op_encrypt_result_invalid_recipients_get(self) -> _gpgme_invalid_key"},
38673 : { (char *)"new__gpgme_op_encrypt_result", _wrap_new__gpgme_op_encrypt_result, METH_VARARGS, (char *)"new__gpgme_op_encrypt_result() -> _gpgme_op_encrypt_result"},
38674 : { (char *)"delete__gpgme_op_encrypt_result", _wrap_delete__gpgme_op_encrypt_result, METH_VARARGS, (char *)"delete__gpgme_op_encrypt_result(self)"},
38675 : { (char *)"_gpgme_op_encrypt_result_swigregister", _gpgme_op_encrypt_result_swigregister, METH_VARARGS, NULL},
38676 : { (char *)"gpgme_op_encrypt_result", _wrap_gpgme_op_encrypt_result, METH_VARARGS, (char *)"gpgme_op_encrypt_result(ctx) -> _gpgme_op_encrypt_result"},
38677 : { (char *)"gpgme_op_encrypt_start", _wrap_gpgme_op_encrypt_start, METH_VARARGS, (char *)"gpgme_op_encrypt_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
38678 : { (char *)"gpgme_op_encrypt", _wrap_gpgme_op_encrypt, METH_VARARGS, (char *)"gpgme_op_encrypt(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
38679 : { (char *)"gpgme_op_encrypt_sign_start", _wrap_gpgme_op_encrypt_sign_start, METH_VARARGS, (char *)"gpgme_op_encrypt_sign_start(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
38680 : { (char *)"gpgme_op_encrypt_sign", _wrap_gpgme_op_encrypt_sign, METH_VARARGS, (char *)"gpgme_op_encrypt_sign(ctx, recp, flags, plain, cipher) -> gpgme_error_t"},
38681 : { (char *)"_gpgme_recipient_keyid_set", _wrap__gpgme_recipient_keyid_set, METH_VARARGS, (char *)"_gpgme_recipient_keyid_set(self, keyid)"},
38682 : { (char *)"_gpgme_recipient_keyid_get", _wrap__gpgme_recipient_keyid_get, METH_VARARGS, (char *)"_gpgme_recipient_keyid_get(self) -> char *"},
38683 : { (char *)"_gpgme_recipient__keyid_set", _wrap__gpgme_recipient__keyid_set, METH_VARARGS, (char *)"_gpgme_recipient__keyid_set(self, _keyid)"},
38684 : { (char *)"_gpgme_recipient__keyid_get", _wrap__gpgme_recipient__keyid_get, METH_VARARGS, (char *)"_gpgme_recipient__keyid_get(self) -> char [16+1]"},
38685 : { (char *)"_gpgme_recipient_pubkey_algo_set", _wrap__gpgme_recipient_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_recipient_pubkey_algo_set(self, pubkey_algo)"},
38686 : { (char *)"_gpgme_recipient_pubkey_algo_get", _wrap__gpgme_recipient_pubkey_algo_get, METH_VARARGS, (char *)"_gpgme_recipient_pubkey_algo_get(self) -> gpgme_pubkey_algo_t"},
38687 : { (char *)"_gpgme_recipient_status_set", _wrap__gpgme_recipient_status_set, METH_VARARGS, (char *)"_gpgme_recipient_status_set(self, status)"},
38688 : { (char *)"_gpgme_recipient_status_get", _wrap__gpgme_recipient_status_get, METH_VARARGS, (char *)"_gpgme_recipient_status_get(self) -> gpgme_error_t"},
38689 : { (char *)"new__gpgme_recipient", _wrap_new__gpgme_recipient, METH_VARARGS, (char *)"new__gpgme_recipient() -> _gpgme_recipient"},
38690 : { (char *)"delete__gpgme_recipient", _wrap_delete__gpgme_recipient, METH_VARARGS, (char *)"delete__gpgme_recipient(self)"},
38691 : { (char *)"_gpgme_recipient_swigregister", _gpgme_recipient_swigregister, METH_VARARGS, NULL},
38692 : { (char *)"_gpgme_op_decrypt_result_unsupported_algorithm_set", _wrap__gpgme_op_decrypt_result_unsupported_algorithm_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_unsupported_algorithm_set(self, unsupported_algorithm)"},
38693 : { (char *)"_gpgme_op_decrypt_result_unsupported_algorithm_get", _wrap__gpgme_op_decrypt_result_unsupported_algorithm_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_unsupported_algorithm_get(self) -> char *"},
38694 : { (char *)"_gpgme_op_decrypt_result_wrong_key_usage_set", _wrap__gpgme_op_decrypt_result_wrong_key_usage_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_wrong_key_usage_set(self, wrong_key_usage)"},
38695 : { (char *)"_gpgme_op_decrypt_result_wrong_key_usage_get", _wrap__gpgme_op_decrypt_result_wrong_key_usage_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_wrong_key_usage_get(self) -> unsigned int"},
38696 : { (char *)"_gpgme_op_decrypt_result__unused_set", _wrap__gpgme_op_decrypt_result__unused_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result__unused_set(self, _unused)"},
38697 : { (char *)"_gpgme_op_decrypt_result__unused_get", _wrap__gpgme_op_decrypt_result__unused_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result__unused_get(self) -> int"},
38698 : { (char *)"_gpgme_op_decrypt_result_recipients_set", _wrap__gpgme_op_decrypt_result_recipients_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_recipients_set(self, recipients)"},
38699 : { (char *)"_gpgme_op_decrypt_result_recipients_get", _wrap__gpgme_op_decrypt_result_recipients_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_recipients_get(self) -> _gpgme_recipient"},
38700 : { (char *)"_gpgme_op_decrypt_result_file_name_set", _wrap__gpgme_op_decrypt_result_file_name_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_file_name_set(self, file_name)"},
38701 : { (char *)"_gpgme_op_decrypt_result_file_name_get", _wrap__gpgme_op_decrypt_result_file_name_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_file_name_get(self) -> char *"},
38702 : { (char *)"_gpgme_op_decrypt_result_session_key_set", _wrap__gpgme_op_decrypt_result_session_key_set, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_session_key_set(self, session_key)"},
38703 : { (char *)"_gpgme_op_decrypt_result_session_key_get", _wrap__gpgme_op_decrypt_result_session_key_get, METH_VARARGS, (char *)"_gpgme_op_decrypt_result_session_key_get(self) -> char *"},
38704 : { (char *)"new__gpgme_op_decrypt_result", _wrap_new__gpgme_op_decrypt_result, METH_VARARGS, (char *)"new__gpgme_op_decrypt_result() -> _gpgme_op_decrypt_result"},
38705 : { (char *)"delete__gpgme_op_decrypt_result", _wrap_delete__gpgme_op_decrypt_result, METH_VARARGS, (char *)"delete__gpgme_op_decrypt_result(self)"},
38706 : { (char *)"_gpgme_op_decrypt_result_swigregister", _gpgme_op_decrypt_result_swigregister, METH_VARARGS, NULL},
38707 : { (char *)"gpgme_op_decrypt_result", _wrap_gpgme_op_decrypt_result, METH_VARARGS, (char *)"gpgme_op_decrypt_result(ctx) -> _gpgme_op_decrypt_result"},
38708 : { (char *)"gpgme_op_decrypt_start", _wrap_gpgme_op_decrypt_start, METH_VARARGS, (char *)"gpgme_op_decrypt_start(ctx, cipher, plain) -> gpgme_error_t"},
38709 : { (char *)"gpgme_op_decrypt", _wrap_gpgme_op_decrypt, METH_VARARGS, (char *)"gpgme_op_decrypt(ctx, cipher, plain) -> gpgme_error_t"},
38710 : { (char *)"gpgme_op_decrypt_verify_start", _wrap_gpgme_op_decrypt_verify_start, METH_VARARGS, (char *)"gpgme_op_decrypt_verify_start(ctx, cipher, plain) -> gpgme_error_t"},
38711 : { (char *)"gpgme_op_decrypt_verify", _wrap_gpgme_op_decrypt_verify, METH_VARARGS, (char *)"gpgme_op_decrypt_verify(ctx, cipher, plain) -> gpgme_error_t"},
38712 : { (char *)"_gpgme_new_signature_type_set", _wrap__gpgme_new_signature_type_set, METH_VARARGS, (char *)"_gpgme_new_signature_type_set(self, type)"},
38713 : { (char *)"_gpgme_new_signature_type_get", _wrap__gpgme_new_signature_type_get, METH_VARARGS, (char *)"_gpgme_new_signature_type_get(self) -> gpgme_sig_mode_t"},
38714 : { (char *)"_gpgme_new_signature_pubkey_algo_set", _wrap__gpgme_new_signature_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_new_signature_pubkey_algo_set(self, pubkey_algo)"},
38715 : { (char *)"_gpgme_new_signature_pubkey_algo_get", _wrap__gpgme_new_signature_pubkey_algo_get, METH_VARARGS, (char *)"_gpgme_new_signature_pubkey_algo_get(self) -> gpgme_pubkey_algo_t"},
38716 : { (char *)"_gpgme_new_signature_hash_algo_set", _wrap__gpgme_new_signature_hash_algo_set, METH_VARARGS, (char *)"_gpgme_new_signature_hash_algo_set(self, hash_algo)"},
38717 : { (char *)"_gpgme_new_signature_hash_algo_get", _wrap__gpgme_new_signature_hash_algo_get, METH_VARARGS, (char *)"_gpgme_new_signature_hash_algo_get(self) -> gpgme_hash_algo_t"},
38718 : { (char *)"_gpgme_new_signature__obsolete_class_set", _wrap__gpgme_new_signature__obsolete_class_set, METH_VARARGS, (char *)"_gpgme_new_signature__obsolete_class_set(self, _obsolete_class)"},
38719 : { (char *)"_gpgme_new_signature__obsolete_class_get", _wrap__gpgme_new_signature__obsolete_class_get, METH_VARARGS, (char *)"_gpgme_new_signature__obsolete_class_get(self) -> unsigned long"},
38720 : { (char *)"_gpgme_new_signature_timestamp_set", _wrap__gpgme_new_signature_timestamp_set, METH_VARARGS, (char *)"_gpgme_new_signature_timestamp_set(self, timestamp)"},
38721 : { (char *)"_gpgme_new_signature_timestamp_get", _wrap__gpgme_new_signature_timestamp_get, METH_VARARGS, (char *)"_gpgme_new_signature_timestamp_get(self) -> long"},
38722 : { (char *)"_gpgme_new_signature_fpr_set", _wrap__gpgme_new_signature_fpr_set, METH_VARARGS, (char *)"_gpgme_new_signature_fpr_set(self, fpr)"},
38723 : { (char *)"_gpgme_new_signature_fpr_get", _wrap__gpgme_new_signature_fpr_get, METH_VARARGS, (char *)"_gpgme_new_signature_fpr_get(self) -> char *"},
38724 : { (char *)"_gpgme_new_signature_sig_class_set", _wrap__gpgme_new_signature_sig_class_set, METH_VARARGS, (char *)"_gpgme_new_signature_sig_class_set(self, sig_class)"},
38725 : { (char *)"_gpgme_new_signature_sig_class_get", _wrap__gpgme_new_signature_sig_class_get, METH_VARARGS, (char *)"_gpgme_new_signature_sig_class_get(self) -> unsigned int"},
38726 : { (char *)"new__gpgme_new_signature", _wrap_new__gpgme_new_signature, METH_VARARGS, (char *)"new__gpgme_new_signature() -> _gpgme_new_signature"},
38727 : { (char *)"delete__gpgme_new_signature", _wrap_delete__gpgme_new_signature, METH_VARARGS, (char *)"delete__gpgme_new_signature(self)"},
38728 : { (char *)"_gpgme_new_signature_swigregister", _gpgme_new_signature_swigregister, METH_VARARGS, NULL},
38729 : { (char *)"_gpgme_op_sign_result_invalid_signers_set", _wrap__gpgme_op_sign_result_invalid_signers_set, METH_VARARGS, (char *)"_gpgme_op_sign_result_invalid_signers_set(self, invalid_signers)"},
38730 : { (char *)"_gpgme_op_sign_result_invalid_signers_get", _wrap__gpgme_op_sign_result_invalid_signers_get, METH_VARARGS, (char *)"_gpgme_op_sign_result_invalid_signers_get(self) -> _gpgme_invalid_key"},
38731 : { (char *)"_gpgme_op_sign_result_signatures_set", _wrap__gpgme_op_sign_result_signatures_set, METH_VARARGS, (char *)"_gpgme_op_sign_result_signatures_set(self, signatures)"},
38732 : { (char *)"_gpgme_op_sign_result_signatures_get", _wrap__gpgme_op_sign_result_signatures_get, METH_VARARGS, (char *)"_gpgme_op_sign_result_signatures_get(self) -> _gpgme_new_signature"},
38733 : { (char *)"new__gpgme_op_sign_result", _wrap_new__gpgme_op_sign_result, METH_VARARGS, (char *)"new__gpgme_op_sign_result() -> _gpgme_op_sign_result"},
38734 : { (char *)"delete__gpgme_op_sign_result", _wrap_delete__gpgme_op_sign_result, METH_VARARGS, (char *)"delete__gpgme_op_sign_result(self)"},
38735 : { (char *)"_gpgme_op_sign_result_swigregister", _gpgme_op_sign_result_swigregister, METH_VARARGS, NULL},
38736 : { (char *)"gpgme_op_sign_result", _wrap_gpgme_op_sign_result, METH_VARARGS, (char *)"gpgme_op_sign_result(ctx) -> _gpgme_op_sign_result"},
38737 : { (char *)"gpgme_op_sign_start", _wrap_gpgme_op_sign_start, METH_VARARGS, (char *)"gpgme_op_sign_start(ctx, plain, sig, mode) -> gpgme_error_t"},
38738 : { (char *)"gpgme_op_sign", _wrap_gpgme_op_sign, METH_VARARGS, (char *)"gpgme_op_sign(ctx, plain, sig, mode) -> gpgme_error_t"},
38739 : { (char *)"_gpgme_signature_summary_set", _wrap__gpgme_signature_summary_set, METH_VARARGS, (char *)"_gpgme_signature_summary_set(self, summary)"},
38740 : { (char *)"_gpgme_signature_summary_get", _wrap__gpgme_signature_summary_get, METH_VARARGS, (char *)"_gpgme_signature_summary_get(self) -> gpgme_sigsum_t"},
38741 : { (char *)"_gpgme_signature_fpr_set", _wrap__gpgme_signature_fpr_set, METH_VARARGS, (char *)"_gpgme_signature_fpr_set(self, fpr)"},
38742 : { (char *)"_gpgme_signature_fpr_get", _wrap__gpgme_signature_fpr_get, METH_VARARGS, (char *)"_gpgme_signature_fpr_get(self) -> char *"},
38743 : { (char *)"_gpgme_signature_status_set", _wrap__gpgme_signature_status_set, METH_VARARGS, (char *)"_gpgme_signature_status_set(self, status)"},
38744 : { (char *)"_gpgme_signature_status_get", _wrap__gpgme_signature_status_get, METH_VARARGS, (char *)"_gpgme_signature_status_get(self) -> gpgme_error_t"},
38745 : { (char *)"_gpgme_signature_notations_set", _wrap__gpgme_signature_notations_set, METH_VARARGS, (char *)"_gpgme_signature_notations_set(self, notations)"},
38746 : { (char *)"_gpgme_signature_notations_get", _wrap__gpgme_signature_notations_get, METH_VARARGS, (char *)"_gpgme_signature_notations_get(self) -> _gpgme_sig_notation"},
38747 : { (char *)"_gpgme_signature_timestamp_set", _wrap__gpgme_signature_timestamp_set, METH_VARARGS, (char *)"_gpgme_signature_timestamp_set(self, timestamp)"},
38748 : { (char *)"_gpgme_signature_timestamp_get", _wrap__gpgme_signature_timestamp_get, METH_VARARGS, (char *)"_gpgme_signature_timestamp_get(self) -> unsigned long"},
38749 : { (char *)"_gpgme_signature_exp_timestamp_set", _wrap__gpgme_signature_exp_timestamp_set, METH_VARARGS, (char *)"_gpgme_signature_exp_timestamp_set(self, exp_timestamp)"},
38750 : { (char *)"_gpgme_signature_exp_timestamp_get", _wrap__gpgme_signature_exp_timestamp_get, METH_VARARGS, (char *)"_gpgme_signature_exp_timestamp_get(self) -> unsigned long"},
38751 : { (char *)"_gpgme_signature_wrong_key_usage_set", _wrap__gpgme_signature_wrong_key_usage_set, METH_VARARGS, (char *)"_gpgme_signature_wrong_key_usage_set(self, wrong_key_usage)"},
38752 : { (char *)"_gpgme_signature_wrong_key_usage_get", _wrap__gpgme_signature_wrong_key_usage_get, METH_VARARGS, (char *)"_gpgme_signature_wrong_key_usage_get(self) -> unsigned int"},
38753 : { (char *)"_gpgme_signature_pka_trust_set", _wrap__gpgme_signature_pka_trust_set, METH_VARARGS, (char *)"_gpgme_signature_pka_trust_set(self, pka_trust)"},
38754 : { (char *)"_gpgme_signature_pka_trust_get", _wrap__gpgme_signature_pka_trust_get, METH_VARARGS, (char *)"_gpgme_signature_pka_trust_get(self) -> unsigned int"},
38755 : { (char *)"_gpgme_signature_chain_model_set", _wrap__gpgme_signature_chain_model_set, METH_VARARGS, (char *)"_gpgme_signature_chain_model_set(self, chain_model)"},
38756 : { (char *)"_gpgme_signature_chain_model_get", _wrap__gpgme_signature_chain_model_get, METH_VARARGS, (char *)"_gpgme_signature_chain_model_get(self) -> unsigned int"},
38757 : { (char *)"_gpgme_signature__unused_set", _wrap__gpgme_signature__unused_set, METH_VARARGS, (char *)"_gpgme_signature__unused_set(self, _unused)"},
38758 : { (char *)"_gpgme_signature__unused_get", _wrap__gpgme_signature__unused_get, METH_VARARGS, (char *)"_gpgme_signature__unused_get(self) -> int"},
38759 : { (char *)"_gpgme_signature_validity_set", _wrap__gpgme_signature_validity_set, METH_VARARGS, (char *)"_gpgme_signature_validity_set(self, validity)"},
38760 : { (char *)"_gpgme_signature_validity_get", _wrap__gpgme_signature_validity_get, METH_VARARGS, (char *)"_gpgme_signature_validity_get(self) -> gpgme_validity_t"},
38761 : { (char *)"_gpgme_signature_validity_reason_set", _wrap__gpgme_signature_validity_reason_set, METH_VARARGS, (char *)"_gpgme_signature_validity_reason_set(self, validity_reason)"},
38762 : { (char *)"_gpgme_signature_validity_reason_get", _wrap__gpgme_signature_validity_reason_get, METH_VARARGS, (char *)"_gpgme_signature_validity_reason_get(self) -> gpgme_error_t"},
38763 : { (char *)"_gpgme_signature_pubkey_algo_set", _wrap__gpgme_signature_pubkey_algo_set, METH_VARARGS, (char *)"_gpgme_signature_pubkey_algo_set(self, pubkey_algo)"},
38764 : { (char *)"_gpgme_signature_pubkey_algo_get", _wrap__gpgme_signature_pubkey_algo_get, METH_VARARGS, (char *)"_gpgme_signature_pubkey_algo_get(self) -> gpgme_pubkey_algo_t"},
38765 : { (char *)"_gpgme_signature_hash_algo_set", _wrap__gpgme_signature_hash_algo_set, METH_VARARGS, (char *)"_gpgme_signature_hash_algo_set(self, hash_algo)"},
38766 : { (char *)"_gpgme_signature_hash_algo_get", _wrap__gpgme_signature_hash_algo_get, METH_VARARGS, (char *)"_gpgme_signature_hash_algo_get(self) -> gpgme_hash_algo_t"},
38767 : { (char *)"_gpgme_signature_pka_address_set", _wrap__gpgme_signature_pka_address_set, METH_VARARGS, (char *)"_gpgme_signature_pka_address_set(self, pka_address)"},
38768 : { (char *)"_gpgme_signature_pka_address_get", _wrap__gpgme_signature_pka_address_get, METH_VARARGS, (char *)"_gpgme_signature_pka_address_get(self) -> char *"},
38769 : { (char *)"_gpgme_signature_key_set", _wrap__gpgme_signature_key_set, METH_VARARGS, (char *)"_gpgme_signature_key_set(self, key)"},
38770 : { (char *)"_gpgme_signature_key_get", _wrap__gpgme_signature_key_get, METH_VARARGS, (char *)"_gpgme_signature_key_get(self) -> _gpgme_key"},
38771 : { (char *)"new__gpgme_signature", _wrap_new__gpgme_signature, METH_VARARGS, (char *)"new__gpgme_signature() -> _gpgme_signature"},
38772 : { (char *)"delete__gpgme_signature", _wrap_delete__gpgme_signature, METH_VARARGS, (char *)"delete__gpgme_signature(self)"},
38773 : { (char *)"_gpgme_signature_swigregister", _gpgme_signature_swigregister, METH_VARARGS, NULL},
38774 : { (char *)"_gpgme_op_verify_result_signatures_set", _wrap__gpgme_op_verify_result_signatures_set, METH_VARARGS, (char *)"_gpgme_op_verify_result_signatures_set(self, signatures)"},
38775 : { (char *)"_gpgme_op_verify_result_signatures_get", _wrap__gpgme_op_verify_result_signatures_get, METH_VARARGS, (char *)"_gpgme_op_verify_result_signatures_get(self) -> _gpgme_signature"},
38776 : { (char *)"_gpgme_op_verify_result_file_name_set", _wrap__gpgme_op_verify_result_file_name_set, METH_VARARGS, (char *)"_gpgme_op_verify_result_file_name_set(self, file_name)"},
38777 : { (char *)"_gpgme_op_verify_result_file_name_get", _wrap__gpgme_op_verify_result_file_name_get, METH_VARARGS, (char *)"_gpgme_op_verify_result_file_name_get(self) -> char *"},
38778 : { (char *)"new__gpgme_op_verify_result", _wrap_new__gpgme_op_verify_result, METH_VARARGS, (char *)"new__gpgme_op_verify_result() -> _gpgme_op_verify_result"},
38779 : { (char *)"delete__gpgme_op_verify_result", _wrap_delete__gpgme_op_verify_result, METH_VARARGS, (char *)"delete__gpgme_op_verify_result(self)"},
38780 : { (char *)"_gpgme_op_verify_result_swigregister", _gpgme_op_verify_result_swigregister, METH_VARARGS, NULL},
38781 : { (char *)"gpgme_op_verify_result", _wrap_gpgme_op_verify_result, METH_VARARGS, (char *)"gpgme_op_verify_result(ctx) -> _gpgme_op_verify_result"},
38782 : { (char *)"gpgme_op_verify_start", _wrap_gpgme_op_verify_start, METH_VARARGS, (char *)"gpgme_op_verify_start(ctx, sig, signed_text, plaintext) -> gpgme_error_t"},
38783 : { (char *)"gpgme_op_verify", _wrap_gpgme_op_verify, METH_VARARGS, (char *)"gpgme_op_verify(ctx, sig, signed_text, plaintext) -> gpgme_error_t"},
38784 : { (char *)"_gpgme_import_status_fpr_set", _wrap__gpgme_import_status_fpr_set, METH_VARARGS, (char *)"_gpgme_import_status_fpr_set(self, fpr)"},
38785 : { (char *)"_gpgme_import_status_fpr_get", _wrap__gpgme_import_status_fpr_get, METH_VARARGS, (char *)"_gpgme_import_status_fpr_get(self) -> char *"},
38786 : { (char *)"_gpgme_import_status_result_set", _wrap__gpgme_import_status_result_set, METH_VARARGS, (char *)"_gpgme_import_status_result_set(self, result)"},
38787 : { (char *)"_gpgme_import_status_result_get", _wrap__gpgme_import_status_result_get, METH_VARARGS, (char *)"_gpgme_import_status_result_get(self) -> gpgme_error_t"},
38788 : { (char *)"_gpgme_import_status_status_set", _wrap__gpgme_import_status_status_set, METH_VARARGS, (char *)"_gpgme_import_status_status_set(self, status)"},
38789 : { (char *)"_gpgme_import_status_status_get", _wrap__gpgme_import_status_status_get, METH_VARARGS, (char *)"_gpgme_import_status_status_get(self) -> unsigned int"},
38790 : { (char *)"new__gpgme_import_status", _wrap_new__gpgme_import_status, METH_VARARGS, (char *)"new__gpgme_import_status() -> _gpgme_import_status"},
38791 : { (char *)"delete__gpgme_import_status", _wrap_delete__gpgme_import_status, METH_VARARGS, (char *)"delete__gpgme_import_status(self)"},
38792 : { (char *)"_gpgme_import_status_swigregister", _gpgme_import_status_swigregister, METH_VARARGS, NULL},
38793 : { (char *)"_gpgme_op_import_result_considered_set", _wrap__gpgme_op_import_result_considered_set, METH_VARARGS, (char *)"_gpgme_op_import_result_considered_set(self, considered)"},
38794 : { (char *)"_gpgme_op_import_result_considered_get", _wrap__gpgme_op_import_result_considered_get, METH_VARARGS, (char *)"_gpgme_op_import_result_considered_get(self) -> int"},
38795 : { (char *)"_gpgme_op_import_result_no_user_id_set", _wrap__gpgme_op_import_result_no_user_id_set, METH_VARARGS, (char *)"_gpgme_op_import_result_no_user_id_set(self, no_user_id)"},
38796 : { (char *)"_gpgme_op_import_result_no_user_id_get", _wrap__gpgme_op_import_result_no_user_id_get, METH_VARARGS, (char *)"_gpgme_op_import_result_no_user_id_get(self) -> int"},
38797 : { (char *)"_gpgme_op_import_result_imported_set", _wrap__gpgme_op_import_result_imported_set, METH_VARARGS, (char *)"_gpgme_op_import_result_imported_set(self, imported)"},
38798 : { (char *)"_gpgme_op_import_result_imported_get", _wrap__gpgme_op_import_result_imported_get, METH_VARARGS, (char *)"_gpgme_op_import_result_imported_get(self) -> int"},
38799 : { (char *)"_gpgme_op_import_result_imported_rsa_set", _wrap__gpgme_op_import_result_imported_rsa_set, METH_VARARGS, (char *)"_gpgme_op_import_result_imported_rsa_set(self, imported_rsa)"},
38800 : { (char *)"_gpgme_op_import_result_imported_rsa_get", _wrap__gpgme_op_import_result_imported_rsa_get, METH_VARARGS, (char *)"_gpgme_op_import_result_imported_rsa_get(self) -> int"},
38801 : { (char *)"_gpgme_op_import_result_unchanged_set", _wrap__gpgme_op_import_result_unchanged_set, METH_VARARGS, (char *)"_gpgme_op_import_result_unchanged_set(self, unchanged)"},
38802 : { (char *)"_gpgme_op_import_result_unchanged_get", _wrap__gpgme_op_import_result_unchanged_get, METH_VARARGS, (char *)"_gpgme_op_import_result_unchanged_get(self) -> int"},
38803 : { (char *)"_gpgme_op_import_result_new_user_ids_set", _wrap__gpgme_op_import_result_new_user_ids_set, METH_VARARGS, (char *)"_gpgme_op_import_result_new_user_ids_set(self, new_user_ids)"},
38804 : { (char *)"_gpgme_op_import_result_new_user_ids_get", _wrap__gpgme_op_import_result_new_user_ids_get, METH_VARARGS, (char *)"_gpgme_op_import_result_new_user_ids_get(self) -> int"},
38805 : { (char *)"_gpgme_op_import_result_new_sub_keys_set", _wrap__gpgme_op_import_result_new_sub_keys_set, METH_VARARGS, (char *)"_gpgme_op_import_result_new_sub_keys_set(self, new_sub_keys)"},
38806 : { (char *)"_gpgme_op_import_result_new_sub_keys_get", _wrap__gpgme_op_import_result_new_sub_keys_get, METH_VARARGS, (char *)"_gpgme_op_import_result_new_sub_keys_get(self) -> int"},
38807 : { (char *)"_gpgme_op_import_result_new_signatures_set", _wrap__gpgme_op_import_result_new_signatures_set, METH_VARARGS, (char *)"_gpgme_op_import_result_new_signatures_set(self, new_signatures)"},
38808 : { (char *)"_gpgme_op_import_result_new_signatures_get", _wrap__gpgme_op_import_result_new_signatures_get, METH_VARARGS, (char *)"_gpgme_op_import_result_new_signatures_get(self) -> int"},
38809 : { (char *)"_gpgme_op_import_result_new_revocations_set", _wrap__gpgme_op_import_result_new_revocations_set, METH_VARARGS, (char *)"_gpgme_op_import_result_new_revocations_set(self, new_revocations)"},
38810 : { (char *)"_gpgme_op_import_result_new_revocations_get", _wrap__gpgme_op_import_result_new_revocations_get, METH_VARARGS, (char *)"_gpgme_op_import_result_new_revocations_get(self) -> int"},
38811 : { (char *)"_gpgme_op_import_result_secret_read_set", _wrap__gpgme_op_import_result_secret_read_set, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_read_set(self, secret_read)"},
38812 : { (char *)"_gpgme_op_import_result_secret_read_get", _wrap__gpgme_op_import_result_secret_read_get, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_read_get(self) -> int"},
38813 : { (char *)"_gpgme_op_import_result_secret_imported_set", _wrap__gpgme_op_import_result_secret_imported_set, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_imported_set(self, secret_imported)"},
38814 : { (char *)"_gpgme_op_import_result_secret_imported_get", _wrap__gpgme_op_import_result_secret_imported_get, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_imported_get(self) -> int"},
38815 : { (char *)"_gpgme_op_import_result_secret_unchanged_set", _wrap__gpgme_op_import_result_secret_unchanged_set, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_unchanged_set(self, secret_unchanged)"},
38816 : { (char *)"_gpgme_op_import_result_secret_unchanged_get", _wrap__gpgme_op_import_result_secret_unchanged_get, METH_VARARGS, (char *)"_gpgme_op_import_result_secret_unchanged_get(self) -> int"},
38817 : { (char *)"_gpgme_op_import_result_skipped_new_keys_set", _wrap__gpgme_op_import_result_skipped_new_keys_set, METH_VARARGS, (char *)"_gpgme_op_import_result_skipped_new_keys_set(self, skipped_new_keys)"},
38818 : { (char *)"_gpgme_op_import_result_skipped_new_keys_get", _wrap__gpgme_op_import_result_skipped_new_keys_get, METH_VARARGS, (char *)"_gpgme_op_import_result_skipped_new_keys_get(self) -> int"},
38819 : { (char *)"_gpgme_op_import_result_not_imported_set", _wrap__gpgme_op_import_result_not_imported_set, METH_VARARGS, (char *)"_gpgme_op_import_result_not_imported_set(self, not_imported)"},
38820 : { (char *)"_gpgme_op_import_result_not_imported_get", _wrap__gpgme_op_import_result_not_imported_get, METH_VARARGS, (char *)"_gpgme_op_import_result_not_imported_get(self) -> int"},
38821 : { (char *)"_gpgme_op_import_result_imports_set", _wrap__gpgme_op_import_result_imports_set, METH_VARARGS, (char *)"_gpgme_op_import_result_imports_set(self, imports)"},
38822 : { (char *)"_gpgme_op_import_result_imports_get", _wrap__gpgme_op_import_result_imports_get, METH_VARARGS, (char *)"_gpgme_op_import_result_imports_get(self) -> _gpgme_import_status"},
38823 : { (char *)"new__gpgme_op_import_result", _wrap_new__gpgme_op_import_result, METH_VARARGS, (char *)"new__gpgme_op_import_result() -> _gpgme_op_import_result"},
38824 : { (char *)"delete__gpgme_op_import_result", _wrap_delete__gpgme_op_import_result, METH_VARARGS, (char *)"delete__gpgme_op_import_result(self)"},
38825 : { (char *)"_gpgme_op_import_result_swigregister", _gpgme_op_import_result_swigregister, METH_VARARGS, NULL},
38826 : { (char *)"gpgme_op_import_result", _wrap_gpgme_op_import_result, METH_VARARGS, (char *)"gpgme_op_import_result(ctx) -> _gpgme_op_import_result"},
38827 : { (char *)"gpgme_op_import_start", _wrap_gpgme_op_import_start, METH_VARARGS, (char *)"gpgme_op_import_start(ctx, keydata) -> gpgme_error_t"},
38828 : { (char *)"gpgme_op_import", _wrap_gpgme_op_import, METH_VARARGS, (char *)"gpgme_op_import(ctx, keydata) -> gpgme_error_t"},
38829 : { (char *)"gpgme_op_import_keys_start", _wrap_gpgme_op_import_keys_start, METH_VARARGS, (char *)"gpgme_op_import_keys_start(ctx, keys) -> gpgme_error_t"},
38830 : { (char *)"gpgme_op_import_keys", _wrap_gpgme_op_import_keys, METH_VARARGS, (char *)"gpgme_op_import_keys(ctx, keys) -> gpgme_error_t"},
38831 : { (char *)"gpgme_op_export_start", _wrap_gpgme_op_export_start, METH_VARARGS, (char *)"gpgme_op_export_start(ctx, pattern, mode, keydata) -> gpgme_error_t"},
38832 : { (char *)"gpgme_op_export", _wrap_gpgme_op_export, METH_VARARGS, (char *)"gpgme_op_export(ctx, pattern, mode, keydata) -> gpgme_error_t"},
38833 : { (char *)"gpgme_op_export_ext_start", _wrap_gpgme_op_export_ext_start, METH_VARARGS, (char *)"gpgme_op_export_ext_start(ctx, pattern, mode, keydata) -> gpgme_error_t"},
38834 : { (char *)"gpgme_op_export_ext", _wrap_gpgme_op_export_ext, METH_VARARGS, (char *)"gpgme_op_export_ext(ctx, pattern, mode, keydata) -> gpgme_error_t"},
38835 : { (char *)"gpgme_op_export_keys_start", _wrap_gpgme_op_export_keys_start, METH_VARARGS, (char *)"gpgme_op_export_keys_start(ctx, keys, mode, keydata) -> gpgme_error_t"},
38836 : { (char *)"gpgme_op_export_keys", _wrap_gpgme_op_export_keys, METH_VARARGS, (char *)"gpgme_op_export_keys(ctx, keys, mode, keydata) -> gpgme_error_t"},
38837 : { (char *)"_gpgme_op_genkey_result_primary_set", _wrap__gpgme_op_genkey_result_primary_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_primary_set(self, primary)"},
38838 : { (char *)"_gpgme_op_genkey_result_primary_get", _wrap__gpgme_op_genkey_result_primary_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_primary_get(self) -> unsigned int"},
38839 : { (char *)"_gpgme_op_genkey_result_sub_set", _wrap__gpgme_op_genkey_result_sub_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_sub_set(self, sub)"},
38840 : { (char *)"_gpgme_op_genkey_result_sub_get", _wrap__gpgme_op_genkey_result_sub_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_sub_get(self) -> unsigned int"},
38841 : { (char *)"_gpgme_op_genkey_result_uid_set", _wrap__gpgme_op_genkey_result_uid_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_uid_set(self, uid)"},
38842 : { (char *)"_gpgme_op_genkey_result_uid_get", _wrap__gpgme_op_genkey_result_uid_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_uid_get(self) -> unsigned int"},
38843 : { (char *)"_gpgme_op_genkey_result__unused_set", _wrap__gpgme_op_genkey_result__unused_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result__unused_set(self, _unused)"},
38844 : { (char *)"_gpgme_op_genkey_result__unused_get", _wrap__gpgme_op_genkey_result__unused_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result__unused_get(self) -> unsigned int"},
38845 : { (char *)"_gpgme_op_genkey_result_fpr_set", _wrap__gpgme_op_genkey_result_fpr_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_fpr_set(self, fpr)"},
38846 : { (char *)"_gpgme_op_genkey_result_fpr_get", _wrap__gpgme_op_genkey_result_fpr_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_fpr_get(self) -> char *"},
38847 : { (char *)"_gpgme_op_genkey_result_pubkey_set", _wrap__gpgme_op_genkey_result_pubkey_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_pubkey_set(self, pubkey)"},
38848 : { (char *)"_gpgme_op_genkey_result_pubkey_get", _wrap__gpgme_op_genkey_result_pubkey_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_pubkey_get(self) -> gpgme_data_t"},
38849 : { (char *)"_gpgme_op_genkey_result_seckey_set", _wrap__gpgme_op_genkey_result_seckey_set, METH_VARARGS, (char *)"_gpgme_op_genkey_result_seckey_set(self, seckey)"},
38850 : { (char *)"_gpgme_op_genkey_result_seckey_get", _wrap__gpgme_op_genkey_result_seckey_get, METH_VARARGS, (char *)"_gpgme_op_genkey_result_seckey_get(self) -> gpgme_data_t"},
38851 : { (char *)"new__gpgme_op_genkey_result", _wrap_new__gpgme_op_genkey_result, METH_VARARGS, (char *)"new__gpgme_op_genkey_result() -> _gpgme_op_genkey_result"},
38852 : { (char *)"delete__gpgme_op_genkey_result", _wrap_delete__gpgme_op_genkey_result, METH_VARARGS, (char *)"delete__gpgme_op_genkey_result(self)"},
38853 : { (char *)"_gpgme_op_genkey_result_swigregister", _gpgme_op_genkey_result_swigregister, METH_VARARGS, NULL},
38854 : { (char *)"gpgme_op_genkey_start", _wrap_gpgme_op_genkey_start, METH_VARARGS, (char *)"gpgme_op_genkey_start(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
38855 : { (char *)"gpgme_op_genkey", _wrap_gpgme_op_genkey, METH_VARARGS, (char *)"gpgme_op_genkey(ctx, parms, pubkey, seckey) -> gpgme_error_t"},
38856 : { (char *)"gpgme_op_createkey_start", _wrap_gpgme_op_createkey_start, METH_VARARGS, (char *)"gpgme_op_createkey_start(ctx, userid, algo, reserved, expires, certkey, flags) -> gpgme_error_t"},
38857 : { (char *)"gpgme_op_createkey", _wrap_gpgme_op_createkey, METH_VARARGS, (char *)"gpgme_op_createkey(ctx, userid, algo, reserved, expires, certkey, flags) -> gpgme_error_t"},
38858 : { (char *)"gpgme_op_createsubkey_start", _wrap_gpgme_op_createsubkey_start, METH_VARARGS, (char *)"gpgme_op_createsubkey_start(ctx, key, algo, reserved, expires, flags) -> gpgme_error_t"},
38859 : { (char *)"gpgme_op_createsubkey", _wrap_gpgme_op_createsubkey, METH_VARARGS, (char *)"gpgme_op_createsubkey(ctx, key, algo, reserved, expires, flags) -> gpgme_error_t"},
38860 : { (char *)"gpgme_op_adduid_start", _wrap_gpgme_op_adduid_start, METH_VARARGS, (char *)"gpgme_op_adduid_start(ctx, key, userid, reserved) -> gpgme_error_t"},
38861 : { (char *)"gpgme_op_adduid", _wrap_gpgme_op_adduid, METH_VARARGS, (char *)"gpgme_op_adduid(ctx, key, userid, reserved) -> gpgme_error_t"},
38862 : { (char *)"gpgme_op_revuid_start", _wrap_gpgme_op_revuid_start, METH_VARARGS, (char *)"gpgme_op_revuid_start(ctx, key, userid, reserved) -> gpgme_error_t"},
38863 : { (char *)"gpgme_op_revuid", _wrap_gpgme_op_revuid, METH_VARARGS, (char *)"gpgme_op_revuid(ctx, key, userid, reserved) -> gpgme_error_t"},
38864 : { (char *)"gpgme_op_genkey_result", _wrap_gpgme_op_genkey_result, METH_VARARGS, (char *)"gpgme_op_genkey_result(ctx) -> _gpgme_op_genkey_result"},
38865 : { (char *)"gpgme_op_delete_start", _wrap_gpgme_op_delete_start, METH_VARARGS, (char *)"gpgme_op_delete_start(ctx, key, allow_secret) -> gpgme_error_t"},
38866 : { (char *)"gpgme_op_delete", _wrap_gpgme_op_delete, METH_VARARGS, (char *)"gpgme_op_delete(ctx, key, allow_secret) -> gpgme_error_t"},
38867 : { (char *)"gpgme_op_keysign_start", _wrap_gpgme_op_keysign_start, METH_VARARGS, (char *)"gpgme_op_keysign_start(ctx, key, userid, expires, flags) -> gpgme_error_t"},
38868 : { (char *)"gpgme_op_keysign", _wrap_gpgme_op_keysign, METH_VARARGS, (char *)"gpgme_op_keysign(ctx, key, userid, expires, flags) -> gpgme_error_t"},
38869 : { (char *)"gpgme_op_interact_start", _wrap_gpgme_op_interact_start, METH_VARARGS, (char *)"gpgme_op_interact_start(ctx, key, flags, fnc, out) -> gpgme_error_t"},
38870 : { (char *)"gpgme_op_interact", _wrap_gpgme_op_interact, METH_VARARGS, (char *)"gpgme_op_interact(ctx, key, flags, fnc, out) -> gpgme_error_t"},
38871 : { (char *)"gpgme_op_tofu_policy_start", _wrap_gpgme_op_tofu_policy_start, METH_VARARGS, (char *)"gpgme_op_tofu_policy_start(ctx, key, policy) -> gpgme_error_t"},
38872 : { (char *)"gpgme_op_tofu_policy", _wrap_gpgme_op_tofu_policy, METH_VARARGS, (char *)"gpgme_op_tofu_policy(ctx, key, policy) -> gpgme_error_t"},
38873 : { (char *)"_gpgme_op_keylist_result_truncated_set", _wrap__gpgme_op_keylist_result_truncated_set, METH_VARARGS, (char *)"_gpgme_op_keylist_result_truncated_set(self, truncated)"},
38874 : { (char *)"_gpgme_op_keylist_result_truncated_get", _wrap__gpgme_op_keylist_result_truncated_get, METH_VARARGS, (char *)"_gpgme_op_keylist_result_truncated_get(self) -> unsigned int"},
38875 : { (char *)"_gpgme_op_keylist_result__unused_set", _wrap__gpgme_op_keylist_result__unused_set, METH_VARARGS, (char *)"_gpgme_op_keylist_result__unused_set(self, _unused)"},
38876 : { (char *)"_gpgme_op_keylist_result__unused_get", _wrap__gpgme_op_keylist_result__unused_get, METH_VARARGS, (char *)"_gpgme_op_keylist_result__unused_get(self) -> unsigned int"},
38877 : { (char *)"new__gpgme_op_keylist_result", _wrap_new__gpgme_op_keylist_result, METH_VARARGS, (char *)"new__gpgme_op_keylist_result() -> _gpgme_op_keylist_result"},
38878 : { (char *)"delete__gpgme_op_keylist_result", _wrap_delete__gpgme_op_keylist_result, METH_VARARGS, (char *)"delete__gpgme_op_keylist_result(self)"},
38879 : { (char *)"_gpgme_op_keylist_result_swigregister", _gpgme_op_keylist_result_swigregister, METH_VARARGS, NULL},
38880 : { (char *)"gpgme_op_keylist_result", _wrap_gpgme_op_keylist_result, METH_VARARGS, (char *)"gpgme_op_keylist_result(ctx) -> _gpgme_op_keylist_result"},
38881 : { (char *)"gpgme_op_keylist_ext_start", _wrap_gpgme_op_keylist_ext_start, METH_VARARGS, (char *)"gpgme_op_keylist_ext_start(ctx, pattern, secret_only, reserved) -> gpgme_error_t"},
38882 : { (char *)"gpgme_op_keylist_next", _wrap_gpgme_op_keylist_next, METH_VARARGS, (char *)"gpgme_op_keylist_next(ctx, r_key) -> gpgme_error_t"},
38883 : { (char *)"gpgme_op_keylist_end", _wrap_gpgme_op_keylist_end, METH_VARARGS, (char *)"gpgme_op_keylist_end(ctx) -> gpgme_error_t"},
38884 : { (char *)"gpgme_op_passwd_start", _wrap_gpgme_op_passwd_start, METH_VARARGS, (char *)"gpgme_op_passwd_start(ctx, key, flags) -> gpgme_error_t"},
38885 : { (char *)"gpgme_op_passwd", _wrap_gpgme_op_passwd, METH_VARARGS, (char *)"gpgme_op_passwd(ctx, key, flags) -> gpgme_error_t"},
38886 : { (char *)"_gpgme_trust_item__refs_set", _wrap__gpgme_trust_item__refs_set, METH_VARARGS, (char *)"_gpgme_trust_item__refs_set(self, _refs)"},
38887 : { (char *)"_gpgme_trust_item__refs_get", _wrap__gpgme_trust_item__refs_get, METH_VARARGS, (char *)"_gpgme_trust_item__refs_get(self) -> unsigned int"},
38888 : { (char *)"_gpgme_trust_item_keyid_set", _wrap__gpgme_trust_item_keyid_set, METH_VARARGS, (char *)"_gpgme_trust_item_keyid_set(self, keyid)"},
38889 : { (char *)"_gpgme_trust_item_keyid_get", _wrap__gpgme_trust_item_keyid_get, METH_VARARGS, (char *)"_gpgme_trust_item_keyid_get(self) -> char *"},
38890 : { (char *)"_gpgme_trust_item__keyid_set", _wrap__gpgme_trust_item__keyid_set, METH_VARARGS, (char *)"_gpgme_trust_item__keyid_set(self, _keyid)"},
38891 : { (char *)"_gpgme_trust_item__keyid_get", _wrap__gpgme_trust_item__keyid_get, METH_VARARGS, (char *)"_gpgme_trust_item__keyid_get(self) -> char [16+1]"},
38892 : { (char *)"_gpgme_trust_item_type_set", _wrap__gpgme_trust_item_type_set, METH_VARARGS, (char *)"_gpgme_trust_item_type_set(self, type)"},
38893 : { (char *)"_gpgme_trust_item_type_get", _wrap__gpgme_trust_item_type_get, METH_VARARGS, (char *)"_gpgme_trust_item_type_get(self) -> int"},
38894 : { (char *)"_gpgme_trust_item_level_set", _wrap__gpgme_trust_item_level_set, METH_VARARGS, (char *)"_gpgme_trust_item_level_set(self, level)"},
38895 : { (char *)"_gpgme_trust_item_level_get", _wrap__gpgme_trust_item_level_get, METH_VARARGS, (char *)"_gpgme_trust_item_level_get(self) -> int"},
38896 : { (char *)"_gpgme_trust_item_owner_trust_set", _wrap__gpgme_trust_item_owner_trust_set, METH_VARARGS, (char *)"_gpgme_trust_item_owner_trust_set(self, owner_trust)"},
38897 : { (char *)"_gpgme_trust_item_owner_trust_get", _wrap__gpgme_trust_item_owner_trust_get, METH_VARARGS, (char *)"_gpgme_trust_item_owner_trust_get(self) -> char *"},
38898 : { (char *)"_gpgme_trust_item__owner_trust_set", _wrap__gpgme_trust_item__owner_trust_set, METH_VARARGS, (char *)"_gpgme_trust_item__owner_trust_set(self, _owner_trust)"},
38899 : { (char *)"_gpgme_trust_item__owner_trust_get", _wrap__gpgme_trust_item__owner_trust_get, METH_VARARGS, (char *)"_gpgme_trust_item__owner_trust_get(self) -> char [2]"},
38900 : { (char *)"_gpgme_trust_item_validity_set", _wrap__gpgme_trust_item_validity_set, METH_VARARGS, (char *)"_gpgme_trust_item_validity_set(self, validity)"},
38901 : { (char *)"_gpgme_trust_item_validity_get", _wrap__gpgme_trust_item_validity_get, METH_VARARGS, (char *)"_gpgme_trust_item_validity_get(self) -> char *"},
38902 : { (char *)"_gpgme_trust_item__validity_set", _wrap__gpgme_trust_item__validity_set, METH_VARARGS, (char *)"_gpgme_trust_item__validity_set(self, _validity)"},
38903 : { (char *)"_gpgme_trust_item__validity_get", _wrap__gpgme_trust_item__validity_get, METH_VARARGS, (char *)"_gpgme_trust_item__validity_get(self) -> char [2]"},
38904 : { (char *)"_gpgme_trust_item_name_set", _wrap__gpgme_trust_item_name_set, METH_VARARGS, (char *)"_gpgme_trust_item_name_set(self, name)"},
38905 : { (char *)"_gpgme_trust_item_name_get", _wrap__gpgme_trust_item_name_get, METH_VARARGS, (char *)"_gpgme_trust_item_name_get(self) -> char *"},
38906 : { (char *)"new__gpgme_trust_item", _wrap_new__gpgme_trust_item, METH_VARARGS, (char *)"new__gpgme_trust_item() -> _gpgme_trust_item"},
38907 : { (char *)"delete__gpgme_trust_item", _wrap_delete__gpgme_trust_item, METH_VARARGS, (char *)"delete__gpgme_trust_item(self)"},
38908 : { (char *)"_gpgme_trust_item_swigregister", _gpgme_trust_item_swigregister, METH_VARARGS, NULL},
38909 : { (char *)"gpgme_op_trustlist_start", _wrap_gpgme_op_trustlist_start, METH_VARARGS, (char *)"gpgme_op_trustlist_start(ctx, pattern, max_level) -> gpgme_error_t"},
38910 : { (char *)"gpgme_op_trustlist_next", _wrap_gpgme_op_trustlist_next, METH_VARARGS, (char *)"gpgme_op_trustlist_next(ctx, r_item) -> gpgme_error_t"},
38911 : { (char *)"gpgme_op_trustlist_end", _wrap_gpgme_op_trustlist_end, METH_VARARGS, (char *)"gpgme_op_trustlist_end(ctx) -> gpgme_error_t"},
38912 : { (char *)"gpgme_trust_item_ref", _wrap_gpgme_trust_item_ref, METH_VARARGS, (char *)"gpgme_trust_item_ref(item)"},
38913 : { (char *)"gpgme_trust_item_unref", _wrap_gpgme_trust_item_unref, METH_VARARGS, (char *)"gpgme_trust_item_unref(item)"},
38914 : { (char *)"gpgme_op_getauditlog_start", _wrap_gpgme_op_getauditlog_start, METH_VARARGS, (char *)"gpgme_op_getauditlog_start(ctx, output, flags) -> gpgme_error_t"},
38915 : { (char *)"gpgme_op_getauditlog", _wrap_gpgme_op_getauditlog, METH_VARARGS, (char *)"gpgme_op_getauditlog(ctx, output, flags) -> gpgme_error_t"},
38916 : { (char *)"gpgme_op_spawn_start", _wrap_gpgme_op_spawn_start, METH_VARARGS, (char *)"gpgme_op_spawn_start(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"},
38917 : { (char *)"gpgme_op_spawn", _wrap_gpgme_op_spawn, METH_VARARGS, (char *)"gpgme_op_spawn(ctx, file, argv, datain, dataout, dataerr, flags) -> gpgme_error_t"},
38918 : { (char *)"gpgme_op_assuan_transact_start", _wrap_gpgme_op_assuan_transact_start, METH_VARARGS, (char *)"gpgme_op_assuan_transact_start(ctx, command, data_cb, inq_cb, stat_cb) -> gpgme_error_t"},
38919 : { (char *)"gpgme_op_assuan_transact_ext", _wrap_gpgme_op_assuan_transact_ext, METH_VARARGS, (char *)"gpgme_op_assuan_transact_ext(ctx, command, data_cb, inq_cb, stat_cb, op_err) -> gpgme_error_t"},
38920 : { (char *)"_gpgme_op_vfs_mount_result_mount_dir_set", _wrap__gpgme_op_vfs_mount_result_mount_dir_set, METH_VARARGS, (char *)"_gpgme_op_vfs_mount_result_mount_dir_set(self, mount_dir)"},
38921 : { (char *)"_gpgme_op_vfs_mount_result_mount_dir_get", _wrap__gpgme_op_vfs_mount_result_mount_dir_get, METH_VARARGS, (char *)"_gpgme_op_vfs_mount_result_mount_dir_get(self) -> char *"},
38922 : { (char *)"new__gpgme_op_vfs_mount_result", _wrap_new__gpgme_op_vfs_mount_result, METH_VARARGS, (char *)"new__gpgme_op_vfs_mount_result() -> _gpgme_op_vfs_mount_result"},
38923 : { (char *)"delete__gpgme_op_vfs_mount_result", _wrap_delete__gpgme_op_vfs_mount_result, METH_VARARGS, (char *)"delete__gpgme_op_vfs_mount_result(self)"},
38924 : { (char *)"_gpgme_op_vfs_mount_result_swigregister", _gpgme_op_vfs_mount_result_swigregister, METH_VARARGS, NULL},
38925 : { (char *)"gpgme_op_vfs_mount_result", _wrap_gpgme_op_vfs_mount_result, METH_VARARGS, (char *)"gpgme_op_vfs_mount_result(ctx) -> _gpgme_op_vfs_mount_result"},
38926 : { (char *)"gpgme_op_vfs_mount", _wrap_gpgme_op_vfs_mount, METH_VARARGS, (char *)"gpgme_op_vfs_mount(ctx, container_file, mount_dir, flags, op_err) -> gpgme_error_t"},
38927 : { (char *)"gpgme_op_vfs_create", _wrap_gpgme_op_vfs_create, METH_VARARGS, (char *)"gpgme_op_vfs_create(ctx, recp, container_file, flags, op_err) -> gpgme_error_t"},
38928 : { (char *)"gpgme_conf_arg_no_arg_set", _wrap_gpgme_conf_arg_no_arg_set, METH_VARARGS, (char *)"gpgme_conf_arg_no_arg_set(self, no_arg)"},
38929 : { (char *)"gpgme_conf_arg_no_arg_get", _wrap_gpgme_conf_arg_no_arg_get, METH_VARARGS, (char *)"gpgme_conf_arg_no_arg_get(self) -> unsigned int"},
38930 : { (char *)"gpgme_conf_arg_value_get", _wrap_gpgme_conf_arg_value_get, METH_VARARGS, (char *)"gpgme_conf_arg_value_get(self) -> gpgme_conf_arg_value"},
38931 : { (char *)"new_gpgme_conf_arg", _wrap_new_gpgme_conf_arg, METH_VARARGS, (char *)"new_gpgme_conf_arg() -> gpgme_conf_arg"},
38932 : { (char *)"delete_gpgme_conf_arg", _wrap_delete_gpgme_conf_arg, METH_VARARGS, (char *)"delete_gpgme_conf_arg(self)"},
38933 : { (char *)"gpgme_conf_arg_swigregister", gpgme_conf_arg_swigregister, METH_VARARGS, NULL},
38934 : { (char *)"gpgme_conf_arg_value_count_set", _wrap_gpgme_conf_arg_value_count_set, METH_VARARGS, (char *)"gpgme_conf_arg_value_count_set(self, count)"},
38935 : { (char *)"gpgme_conf_arg_value_count_get", _wrap_gpgme_conf_arg_value_count_get, METH_VARARGS, (char *)"gpgme_conf_arg_value_count_get(self) -> unsigned int"},
38936 : { (char *)"gpgme_conf_arg_value_uint32_set", _wrap_gpgme_conf_arg_value_uint32_set, METH_VARARGS, (char *)"gpgme_conf_arg_value_uint32_set(self, uint32)"},
38937 : { (char *)"gpgme_conf_arg_value_uint32_get", _wrap_gpgme_conf_arg_value_uint32_get, METH_VARARGS, (char *)"gpgme_conf_arg_value_uint32_get(self) -> unsigned int"},
38938 : { (char *)"gpgme_conf_arg_value_int32_set", _wrap_gpgme_conf_arg_value_int32_set, METH_VARARGS, (char *)"gpgme_conf_arg_value_int32_set(self, int32)"},
38939 : { (char *)"gpgme_conf_arg_value_int32_get", _wrap_gpgme_conf_arg_value_int32_get, METH_VARARGS, (char *)"gpgme_conf_arg_value_int32_get(self) -> int"},
38940 : { (char *)"gpgme_conf_arg_value_string_set", _wrap_gpgme_conf_arg_value_string_set, METH_VARARGS, (char *)"gpgme_conf_arg_value_string_set(self, string)"},
38941 : { (char *)"gpgme_conf_arg_value_string_get", _wrap_gpgme_conf_arg_value_string_get, METH_VARARGS, (char *)"gpgme_conf_arg_value_string_get(self) -> char *"},
38942 : { (char *)"new_gpgme_conf_arg_value", _wrap_new_gpgme_conf_arg_value, METH_VARARGS, (char *)"new_gpgme_conf_arg_value() -> gpgme_conf_arg_value"},
38943 : { (char *)"delete_gpgme_conf_arg_value", _wrap_delete_gpgme_conf_arg_value, METH_VARARGS, (char *)"delete_gpgme_conf_arg_value(self)"},
38944 : { (char *)"gpgme_conf_arg_value_swigregister", gpgme_conf_arg_value_swigregister, METH_VARARGS, NULL},
38945 : { (char *)"gpgme_conf_opt_name_set", _wrap_gpgme_conf_opt_name_set, METH_VARARGS, (char *)"gpgme_conf_opt_name_set(self, name)"},
38946 : { (char *)"gpgme_conf_opt_name_get", _wrap_gpgme_conf_opt_name_get, METH_VARARGS, (char *)"gpgme_conf_opt_name_get(self) -> char *"},
38947 : { (char *)"gpgme_conf_opt_flags_set", _wrap_gpgme_conf_opt_flags_set, METH_VARARGS, (char *)"gpgme_conf_opt_flags_set(self, flags)"},
38948 : { (char *)"gpgme_conf_opt_flags_get", _wrap_gpgme_conf_opt_flags_get, METH_VARARGS, (char *)"gpgme_conf_opt_flags_get(self) -> unsigned int"},
38949 : { (char *)"gpgme_conf_opt_level_set", _wrap_gpgme_conf_opt_level_set, METH_VARARGS, (char *)"gpgme_conf_opt_level_set(self, level)"},
38950 : { (char *)"gpgme_conf_opt_level_get", _wrap_gpgme_conf_opt_level_get, METH_VARARGS, (char *)"gpgme_conf_opt_level_get(self) -> gpgme_conf_level_t"},
38951 : { (char *)"gpgme_conf_opt_description_set", _wrap_gpgme_conf_opt_description_set, METH_VARARGS, (char *)"gpgme_conf_opt_description_set(self, description)"},
38952 : { (char *)"gpgme_conf_opt_description_get", _wrap_gpgme_conf_opt_description_get, METH_VARARGS, (char *)"gpgme_conf_opt_description_get(self) -> char *"},
38953 : { (char *)"gpgme_conf_opt_type_set", _wrap_gpgme_conf_opt_type_set, METH_VARARGS, (char *)"gpgme_conf_opt_type_set(self, type)"},
38954 : { (char *)"gpgme_conf_opt_type_get", _wrap_gpgme_conf_opt_type_get, METH_VARARGS, (char *)"gpgme_conf_opt_type_get(self) -> gpgme_conf_type_t"},
38955 : { (char *)"gpgme_conf_opt_alt_type_set", _wrap_gpgme_conf_opt_alt_type_set, METH_VARARGS, (char *)"gpgme_conf_opt_alt_type_set(self, alt_type)"},
38956 : { (char *)"gpgme_conf_opt_alt_type_get", _wrap_gpgme_conf_opt_alt_type_get, METH_VARARGS, (char *)"gpgme_conf_opt_alt_type_get(self) -> gpgme_conf_type_t"},
38957 : { (char *)"gpgme_conf_opt_argname_set", _wrap_gpgme_conf_opt_argname_set, METH_VARARGS, (char *)"gpgme_conf_opt_argname_set(self, argname)"},
38958 : { (char *)"gpgme_conf_opt_argname_get", _wrap_gpgme_conf_opt_argname_get, METH_VARARGS, (char *)"gpgme_conf_opt_argname_get(self) -> char *"},
38959 : { (char *)"gpgme_conf_opt_default_value_set", _wrap_gpgme_conf_opt_default_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_default_value_set(self, default_value)"},
38960 : { (char *)"gpgme_conf_opt_default_value_get", _wrap_gpgme_conf_opt_default_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_default_value_get(self) -> gpgme_conf_arg"},
38961 : { (char *)"gpgme_conf_opt_default_description_set", _wrap_gpgme_conf_opt_default_description_set, METH_VARARGS, (char *)"gpgme_conf_opt_default_description_set(self, default_description)"},
38962 : { (char *)"gpgme_conf_opt_default_description_get", _wrap_gpgme_conf_opt_default_description_get, METH_VARARGS, (char *)"gpgme_conf_opt_default_description_get(self) -> char *"},
38963 : { (char *)"gpgme_conf_opt_no_arg_value_set", _wrap_gpgme_conf_opt_no_arg_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_no_arg_value_set(self, no_arg_value)"},
38964 : { (char *)"gpgme_conf_opt_no_arg_value_get", _wrap_gpgme_conf_opt_no_arg_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_no_arg_value_get(self) -> gpgme_conf_arg"},
38965 : { (char *)"gpgme_conf_opt_no_arg_description_set", _wrap_gpgme_conf_opt_no_arg_description_set, METH_VARARGS, (char *)"gpgme_conf_opt_no_arg_description_set(self, no_arg_description)"},
38966 : { (char *)"gpgme_conf_opt_no_arg_description_get", _wrap_gpgme_conf_opt_no_arg_description_get, METH_VARARGS, (char *)"gpgme_conf_opt_no_arg_description_get(self) -> char *"},
38967 : { (char *)"gpgme_conf_opt_value_set", _wrap_gpgme_conf_opt_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_value_set(self, value)"},
38968 : { (char *)"gpgme_conf_opt_value_get", _wrap_gpgme_conf_opt_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_value_get(self) -> gpgme_conf_arg"},
38969 : { (char *)"gpgme_conf_opt_change_value_set", _wrap_gpgme_conf_opt_change_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_change_value_set(self, change_value)"},
38970 : { (char *)"gpgme_conf_opt_change_value_get", _wrap_gpgme_conf_opt_change_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_change_value_get(self) -> int"},
38971 : { (char *)"gpgme_conf_opt_new_value_set", _wrap_gpgme_conf_opt_new_value_set, METH_VARARGS, (char *)"gpgme_conf_opt_new_value_set(self, new_value)"},
38972 : { (char *)"gpgme_conf_opt_new_value_get", _wrap_gpgme_conf_opt_new_value_get, METH_VARARGS, (char *)"gpgme_conf_opt_new_value_get(self) -> gpgme_conf_arg"},
38973 : { (char *)"gpgme_conf_opt_user_data_set", _wrap_gpgme_conf_opt_user_data_set, METH_VARARGS, (char *)"gpgme_conf_opt_user_data_set(self, user_data)"},
38974 : { (char *)"gpgme_conf_opt_user_data_get", _wrap_gpgme_conf_opt_user_data_get, METH_VARARGS, (char *)"gpgme_conf_opt_user_data_get(self) -> void *"},
38975 : { (char *)"new_gpgme_conf_opt", _wrap_new_gpgme_conf_opt, METH_VARARGS, (char *)"new_gpgme_conf_opt() -> gpgme_conf_opt"},
38976 : { (char *)"delete_gpgme_conf_opt", _wrap_delete_gpgme_conf_opt, METH_VARARGS, (char *)"delete_gpgme_conf_opt(self)"},
38977 : { (char *)"gpgme_conf_opt_swigregister", gpgme_conf_opt_swigregister, METH_VARARGS, NULL},
38978 : { (char *)"gpgme_conf_comp__last_opt_p_set", _wrap_gpgme_conf_comp__last_opt_p_set, METH_VARARGS, (char *)"gpgme_conf_comp__last_opt_p_set(self, _last_opt_p)"},
38979 : { (char *)"gpgme_conf_comp__last_opt_p_get", _wrap_gpgme_conf_comp__last_opt_p_get, METH_VARARGS, (char *)"gpgme_conf_comp__last_opt_p_get(self) -> gpgme_conf_opt_t *"},
38980 : { (char *)"gpgme_conf_comp_name_set", _wrap_gpgme_conf_comp_name_set, METH_VARARGS, (char *)"gpgme_conf_comp_name_set(self, name)"},
38981 : { (char *)"gpgme_conf_comp_name_get", _wrap_gpgme_conf_comp_name_get, METH_VARARGS, (char *)"gpgme_conf_comp_name_get(self) -> char *"},
38982 : { (char *)"gpgme_conf_comp_description_set", _wrap_gpgme_conf_comp_description_set, METH_VARARGS, (char *)"gpgme_conf_comp_description_set(self, description)"},
38983 : { (char *)"gpgme_conf_comp_description_get", _wrap_gpgme_conf_comp_description_get, METH_VARARGS, (char *)"gpgme_conf_comp_description_get(self) -> char *"},
38984 : { (char *)"gpgme_conf_comp_program_name_set", _wrap_gpgme_conf_comp_program_name_set, METH_VARARGS, (char *)"gpgme_conf_comp_program_name_set(self, program_name)"},
38985 : { (char *)"gpgme_conf_comp_program_name_get", _wrap_gpgme_conf_comp_program_name_get, METH_VARARGS, (char *)"gpgme_conf_comp_program_name_get(self) -> char *"},
38986 : { (char *)"gpgme_conf_comp_options_set", _wrap_gpgme_conf_comp_options_set, METH_VARARGS, (char *)"gpgme_conf_comp_options_set(self, options)"},
38987 : { (char *)"gpgme_conf_comp_options_get", _wrap_gpgme_conf_comp_options_get, METH_VARARGS, (char *)"gpgme_conf_comp_options_get(self) -> gpgme_conf_opt"},
38988 : { (char *)"new_gpgme_conf_comp", _wrap_new_gpgme_conf_comp, METH_VARARGS, (char *)"new_gpgme_conf_comp() -> gpgme_conf_comp"},
38989 : { (char *)"delete_gpgme_conf_comp", _wrap_delete_gpgme_conf_comp, METH_VARARGS, (char *)"delete_gpgme_conf_comp(self)"},
38990 : { (char *)"gpgme_conf_comp_swigregister", gpgme_conf_comp_swigregister, METH_VARARGS, NULL},
38991 : { (char *)"gpgme_conf_arg_new", _wrap_gpgme_conf_arg_new, METH_VARARGS, (char *)"gpgme_conf_arg_new(arg_p, type, value) -> gpgme_error_t"},
38992 : { (char *)"gpgme_conf_arg_release", _wrap_gpgme_conf_arg_release, METH_VARARGS, (char *)"gpgme_conf_arg_release(arg, type)"},
38993 : { (char *)"gpgme_conf_opt_change", _wrap_gpgme_conf_opt_change, METH_VARARGS, (char *)"gpgme_conf_opt_change(opt, reset, arg) -> gpgme_error_t"},
38994 : { (char *)"gpgme_conf_release", _wrap_gpgme_conf_release, METH_VARARGS, (char *)"gpgme_conf_release(conf)"},
38995 : { (char *)"gpgme_op_conf_load", _wrap_gpgme_op_conf_load, METH_VARARGS, (char *)"gpgme_op_conf_load(ctx, conf_p) -> gpgme_error_t"},
38996 : { (char *)"gpgme_op_conf_save", _wrap_gpgme_op_conf_save, METH_VARARGS, (char *)"gpgme_op_conf_save(ctx, comp) -> gpgme_error_t"},
38997 : { (char *)"_gpgme_op_query_swdb_result_name_set", _wrap__gpgme_op_query_swdb_result_name_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_name_set(self, name)"},
38998 : { (char *)"_gpgme_op_query_swdb_result_name_get", _wrap__gpgme_op_query_swdb_result_name_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_name_get(self) -> char *"},
38999 : { (char *)"_gpgme_op_query_swdb_result_iversion_set", _wrap__gpgme_op_query_swdb_result_iversion_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_iversion_set(self, iversion)"},
39000 : { (char *)"_gpgme_op_query_swdb_result_iversion_get", _wrap__gpgme_op_query_swdb_result_iversion_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_iversion_get(self) -> char *"},
39001 : { (char *)"_gpgme_op_query_swdb_result_created_set", _wrap__gpgme_op_query_swdb_result_created_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_created_set(self, created)"},
39002 : { (char *)"_gpgme_op_query_swdb_result_created_get", _wrap__gpgme_op_query_swdb_result_created_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_created_get(self) -> unsigned long"},
39003 : { (char *)"_gpgme_op_query_swdb_result_retrieved_set", _wrap__gpgme_op_query_swdb_result_retrieved_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_retrieved_set(self, retrieved)"},
39004 : { (char *)"_gpgme_op_query_swdb_result_retrieved_get", _wrap__gpgme_op_query_swdb_result_retrieved_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_retrieved_get(self) -> unsigned long"},
39005 : { (char *)"_gpgme_op_query_swdb_result_warning_set", _wrap__gpgme_op_query_swdb_result_warning_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_warning_set(self, warning)"},
39006 : { (char *)"_gpgme_op_query_swdb_result_warning_get", _wrap__gpgme_op_query_swdb_result_warning_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_warning_get(self) -> unsigned int"},
39007 : { (char *)"_gpgme_op_query_swdb_result_update_set", _wrap__gpgme_op_query_swdb_result_update_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_update_set(self, update)"},
39008 : { (char *)"_gpgme_op_query_swdb_result_update_get", _wrap__gpgme_op_query_swdb_result_update_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_update_get(self) -> unsigned int"},
39009 : { (char *)"_gpgme_op_query_swdb_result_urgent_set", _wrap__gpgme_op_query_swdb_result_urgent_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_urgent_set(self, urgent)"},
39010 : { (char *)"_gpgme_op_query_swdb_result_urgent_get", _wrap__gpgme_op_query_swdb_result_urgent_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_urgent_get(self) -> unsigned int"},
39011 : { (char *)"_gpgme_op_query_swdb_result_noinfo_set", _wrap__gpgme_op_query_swdb_result_noinfo_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_noinfo_set(self, noinfo)"},
39012 : { (char *)"_gpgme_op_query_swdb_result_noinfo_get", _wrap__gpgme_op_query_swdb_result_noinfo_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_noinfo_get(self) -> unsigned int"},
39013 : { (char *)"_gpgme_op_query_swdb_result_unknown_set", _wrap__gpgme_op_query_swdb_result_unknown_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_unknown_set(self, unknown)"},
39014 : { (char *)"_gpgme_op_query_swdb_result_unknown_get", _wrap__gpgme_op_query_swdb_result_unknown_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_unknown_get(self) -> unsigned int"},
39015 : { (char *)"_gpgme_op_query_swdb_result_tooold_set", _wrap__gpgme_op_query_swdb_result_tooold_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_tooold_set(self, tooold)"},
39016 : { (char *)"_gpgme_op_query_swdb_result_tooold_get", _wrap__gpgme_op_query_swdb_result_tooold_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_tooold_get(self) -> unsigned int"},
39017 : { (char *)"_gpgme_op_query_swdb_result_error_set", _wrap__gpgme_op_query_swdb_result_error_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_error_set(self, error)"},
39018 : { (char *)"_gpgme_op_query_swdb_result_error_get", _wrap__gpgme_op_query_swdb_result_error_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_error_get(self) -> unsigned int"},
39019 : { (char *)"_gpgme_op_query_swdb_result__reserved_set", _wrap__gpgme_op_query_swdb_result__reserved_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result__reserved_set(self, _reserved)"},
39020 : { (char *)"_gpgme_op_query_swdb_result__reserved_get", _wrap__gpgme_op_query_swdb_result__reserved_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result__reserved_get(self) -> unsigned int"},
39021 : { (char *)"_gpgme_op_query_swdb_result_version_set", _wrap__gpgme_op_query_swdb_result_version_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_version_set(self, version)"},
39022 : { (char *)"_gpgme_op_query_swdb_result_version_get", _wrap__gpgme_op_query_swdb_result_version_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_version_get(self) -> char *"},
39023 : { (char *)"_gpgme_op_query_swdb_result_reldate_set", _wrap__gpgme_op_query_swdb_result_reldate_set, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_reldate_set(self, reldate)"},
39024 : { (char *)"_gpgme_op_query_swdb_result_reldate_get", _wrap__gpgme_op_query_swdb_result_reldate_get, METH_VARARGS, (char *)"_gpgme_op_query_swdb_result_reldate_get(self) -> unsigned long"},
39025 : { (char *)"new__gpgme_op_query_swdb_result", _wrap_new__gpgme_op_query_swdb_result, METH_VARARGS, (char *)"new__gpgme_op_query_swdb_result() -> _gpgme_op_query_swdb_result"},
39026 : { (char *)"delete__gpgme_op_query_swdb_result", _wrap_delete__gpgme_op_query_swdb_result, METH_VARARGS, (char *)"delete__gpgme_op_query_swdb_result(self)"},
39027 : { (char *)"_gpgme_op_query_swdb_result_swigregister", _gpgme_op_query_swdb_result_swigregister, METH_VARARGS, NULL},
39028 : { (char *)"gpgme_op_query_swdb", _wrap_gpgme_op_query_swdb, METH_VARARGS, (char *)"gpgme_op_query_swdb(ctx, name, iversion, reserved) -> gpgme_error_t"},
39029 : { (char *)"gpgme_op_query_swdb_result", _wrap_gpgme_op_query_swdb_result, METH_VARARGS, (char *)"gpgme_op_query_swdb_result(ctx) -> _gpgme_op_query_swdb_result"},
39030 : { (char *)"gpgme_set_global_flag", _wrap_gpgme_set_global_flag, METH_VARARGS, (char *)"gpgme_set_global_flag(name, value) -> int"},
39031 : { (char *)"gpgme_check_version", _wrap_gpgme_check_version, METH_VARARGS, (char *)"gpgme_check_version(req_version) -> char const *"},
39032 : { (char *)"gpgme_check_version_internal", _wrap_gpgme_check_version_internal, METH_VARARGS, (char *)"gpgme_check_version_internal(req_version, offset_sig_validity) -> char const *"},
39033 : { (char *)"gpgme_get_dirinfo", _wrap_gpgme_get_dirinfo, METH_VARARGS, (char *)"gpgme_get_dirinfo(what) -> char const *"},
39034 : { (char *)"gpgme_get_engine_info", _wrap_gpgme_get_engine_info, METH_VARARGS, (char *)"gpgme_get_engine_info(engine_info) -> gpgme_error_t"},
39035 : { (char *)"gpgme_set_engine_info", _wrap_gpgme_set_engine_info, METH_VARARGS, (char *)"gpgme_set_engine_info(proto, file_name, home_dir) -> gpgme_error_t"},
39036 : { (char *)"gpgme_engine_check_version", _wrap_gpgme_engine_check_version, METH_VARARGS, (char *)"gpgme_engine_check_version(proto) -> gpgme_error_t"},
39037 : { (char *)"gpgme_result_ref", _wrap_gpgme_result_ref, METH_VARARGS, (char *)"gpgme_result_ref(result)"},
39038 : { (char *)"gpgme_result_unref", _wrap_gpgme_result_unref, METH_VARARGS, (char *)"gpgme_result_unref(result)"},
39039 : { (char *)"gpgme_pubkey_algo_string", _wrap_gpgme_pubkey_algo_string, METH_VARARGS, (char *)"gpgme_pubkey_algo_string(subkey) -> char *"},
39040 : { (char *)"gpgme_pubkey_algo_name", _wrap_gpgme_pubkey_algo_name, METH_VARARGS, (char *)"gpgme_pubkey_algo_name(algo) -> char const *"},
39041 : { (char *)"gpgme_hash_algo_name", _wrap_gpgme_hash_algo_name, METH_VARARGS, (char *)"gpgme_hash_algo_name(algo) -> char const *"},
39042 : { (char *)"gpgme_addrspec_from_uid", _wrap_gpgme_addrspec_from_uid, METH_VARARGS, (char *)"gpgme_addrspec_from_uid(uid) -> char *"},
39043 : { (char *)"new__gpgme_op_assuan_result", _wrap_new__gpgme_op_assuan_result, METH_VARARGS, (char *)"new__gpgme_op_assuan_result() -> _gpgme_op_assuan_result"},
39044 : { (char *)"delete__gpgme_op_assuan_result", _wrap_delete__gpgme_op_assuan_result, METH_VARARGS, (char *)"delete__gpgme_op_assuan_result(self)"},
39045 : { (char *)"_gpgme_op_assuan_result_swigregister", _gpgme_op_assuan_result_swigregister, METH_VARARGS, NULL},
39046 : { (char *)"new_gpgme_ctx_t_p", _wrap_new_gpgme_ctx_t_p, METH_VARARGS, (char *)"new_gpgme_ctx_t_p() -> gpgme_ctx_t *"},
39047 : { (char *)"copy_gpgme_ctx_t_p", _wrap_copy_gpgme_ctx_t_p, METH_VARARGS, (char *)"copy_gpgme_ctx_t_p(value) -> gpgme_ctx_t *"},
39048 : { (char *)"delete_gpgme_ctx_t_p", _wrap_delete_gpgme_ctx_t_p, METH_VARARGS, (char *)"delete_gpgme_ctx_t_p(obj)"},
39049 : { (char *)"gpgme_ctx_t_p_assign", _wrap_gpgme_ctx_t_p_assign, METH_VARARGS, (char *)"gpgme_ctx_t_p_assign(obj, value)"},
39050 : { (char *)"gpgme_ctx_t_p_value", _wrap_gpgme_ctx_t_p_value, METH_VARARGS, (char *)"gpgme_ctx_t_p_value(obj) -> gpgme_ctx_t"},
39051 : { (char *)"new_gpgme_data_t_p", _wrap_new_gpgme_data_t_p, METH_VARARGS, (char *)"new_gpgme_data_t_p() -> gpgme_data_t *"},
39052 : { (char *)"copy_gpgme_data_t_p", _wrap_copy_gpgme_data_t_p, METH_VARARGS, (char *)"copy_gpgme_data_t_p(value) -> gpgme_data_t *"},
39053 : { (char *)"delete_gpgme_data_t_p", _wrap_delete_gpgme_data_t_p, METH_VARARGS, (char *)"delete_gpgme_data_t_p(obj)"},
39054 : { (char *)"gpgme_data_t_p_assign", _wrap_gpgme_data_t_p_assign, METH_VARARGS, (char *)"gpgme_data_t_p_assign(obj, value)"},
39055 : { (char *)"gpgme_data_t_p_value", _wrap_gpgme_data_t_p_value, METH_VARARGS, (char *)"gpgme_data_t_p_value(obj) -> gpgme_data_t"},
39056 : { (char *)"new_gpgme_key_t_p", _wrap_new_gpgme_key_t_p, METH_VARARGS, (char *)"new_gpgme_key_t_p() -> gpgme_key_t *"},
39057 : { (char *)"copy_gpgme_key_t_p", _wrap_copy_gpgme_key_t_p, METH_VARARGS, (char *)"copy_gpgme_key_t_p(value) -> gpgme_key_t *"},
39058 : { (char *)"delete_gpgme_key_t_p", _wrap_delete_gpgme_key_t_p, METH_VARARGS, (char *)"delete_gpgme_key_t_p(obj)"},
39059 : { (char *)"gpgme_key_t_p_assign", _wrap_gpgme_key_t_p_assign, METH_VARARGS, (char *)"gpgme_key_t_p_assign(obj, value)"},
39060 : { (char *)"gpgme_key_t_p_value", _wrap_gpgme_key_t_p_value, METH_VARARGS, (char *)"gpgme_key_t_p_value(obj) -> _gpgme_key"},
39061 : { (char *)"new_gpgme_error_t_p", _wrap_new_gpgme_error_t_p, METH_VARARGS, (char *)"new_gpgme_error_t_p() -> gpgme_error_t *"},
39062 : { (char *)"copy_gpgme_error_t_p", _wrap_copy_gpgme_error_t_p, METH_VARARGS, (char *)"copy_gpgme_error_t_p(value) -> gpgme_error_t *"},
39063 : { (char *)"delete_gpgme_error_t_p", _wrap_delete_gpgme_error_t_p, METH_VARARGS, (char *)"delete_gpgme_error_t_p(obj)"},
39064 : { (char *)"gpgme_error_t_p_assign", _wrap_gpgme_error_t_p_assign, METH_VARARGS, (char *)"gpgme_error_t_p_assign(obj, value)"},
39065 : { (char *)"gpgme_error_t_p_value", _wrap_gpgme_error_t_p_value, METH_VARARGS, (char *)"gpgme_error_t_p_value(obj) -> gpgme_error_t"},
39066 : { (char *)"new_gpgme_trust_item_t_p", _wrap_new_gpgme_trust_item_t_p, METH_VARARGS, (char *)"new_gpgme_trust_item_t_p() -> gpgme_trust_item_t *"},
39067 : { (char *)"copy_gpgme_trust_item_t_p", _wrap_copy_gpgme_trust_item_t_p, METH_VARARGS, (char *)"copy_gpgme_trust_item_t_p(value) -> gpgme_trust_item_t *"},
39068 : { (char *)"delete_gpgme_trust_item_t_p", _wrap_delete_gpgme_trust_item_t_p, METH_VARARGS, (char *)"delete_gpgme_trust_item_t_p(obj)"},
39069 : { (char *)"gpgme_trust_item_t_p_assign", _wrap_gpgme_trust_item_t_p_assign, METH_VARARGS, (char *)"gpgme_trust_item_t_p_assign(obj, value)"},
39070 : { (char *)"gpgme_trust_item_t_p_value", _wrap_gpgme_trust_item_t_p_value, METH_VARARGS, (char *)"gpgme_trust_item_t_p_value(obj) -> _gpgme_trust_item"},
39071 : { (char *)"new_gpgme_engine_info_t_p", _wrap_new_gpgme_engine_info_t_p, METH_VARARGS, (char *)"new_gpgme_engine_info_t_p() -> gpgme_engine_info_t *"},
39072 : { (char *)"copy_gpgme_engine_info_t_p", _wrap_copy_gpgme_engine_info_t_p, METH_VARARGS, (char *)"copy_gpgme_engine_info_t_p(value) -> gpgme_engine_info_t *"},
39073 : { (char *)"delete_gpgme_engine_info_t_p", _wrap_delete_gpgme_engine_info_t_p, METH_VARARGS, (char *)"delete_gpgme_engine_info_t_p(obj)"},
39074 : { (char *)"gpgme_engine_info_t_p_assign", _wrap_gpgme_engine_info_t_p_assign, METH_VARARGS, (char *)"gpgme_engine_info_t_p_assign(obj, value)"},
39075 : { (char *)"gpgme_engine_info_t_p_value", _wrap_gpgme_engine_info_t_p_value, METH_VARARGS, (char *)"gpgme_engine_info_t_p_value(obj) -> _gpgme_engine_info"},
39076 : { (char *)"fdopen", _wrap_fdopen, METH_VARARGS, (char *)"fdopen(fildes, mode) -> FILE *"},
39077 : { (char *)"gpg_raise_callback_exception", _wrap_gpg_raise_callback_exception, METH_VARARGS, (char *)"gpg_raise_callback_exception(arg1) -> PyObject *"},
39078 : { (char *)"gpg_set_passphrase_cb", _wrap_gpg_set_passphrase_cb, METH_VARARGS, (char *)"gpg_set_passphrase_cb(arg1, cb) -> PyObject *"},
39079 : { (char *)"gpg_set_progress_cb", _wrap_gpg_set_progress_cb, METH_VARARGS, (char *)"gpg_set_progress_cb(arg1, cb) -> PyObject *"},
39080 : { (char *)"gpg_set_status_cb", _wrap_gpg_set_status_cb, METH_VARARGS, (char *)"gpg_set_status_cb(arg1, cb) -> PyObject *"},
39081 : { (char *)"gpg_data_new_from_cbs", _wrap_gpg_data_new_from_cbs, METH_VARARGS, (char *)"gpg_data_new_from_cbs(arg1, pycbs, r_data) -> PyObject *"},
39082 : { NULL, NULL, 0, NULL }
39083 : };
39084 :
39085 :
39086 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
39087 :
39088 : static swig_type_info _swigt__p_FILE = {"_p_FILE", "FILE *", 0, 0, (void*)0, 0};
39089 : static swig_type_info _swigt__p__gpgme_attr_t = {"_p__gpgme_attr_t", "enum _gpgme_attr_t *|_gpgme_attr_t *", 0, 0, (void*)0, 0};
39090 : static swig_type_info _swigt__p__gpgme_engine_info = {"_p__gpgme_engine_info", "struct _gpgme_engine_info *|_gpgme_engine_info *|gpgme_engine_info_t", 0, 0, (void*)0, 0};
39091 : static swig_type_info _swigt__p__gpgme_import_status = {"_p__gpgme_import_status", "gpgme_import_status_t|struct _gpgme_import_status *|_gpgme_import_status *", 0, 0, (void*)0, 0};
39092 : static swig_type_info _swigt__p__gpgme_invalid_key = {"_p__gpgme_invalid_key", "struct _gpgme_invalid_key *|_gpgme_invalid_key *|gpgme_invalid_key_t", 0, 0, (void*)0, 0};
39093 : static swig_type_info _swigt__p__gpgme_key = {"_p__gpgme_key", "struct _gpgme_key *|_gpgme_key *|gpgme_key_t", 0, 0, (void*)0, 0};
39094 : static swig_type_info _swigt__p__gpgme_key_sig = {"_p__gpgme_key_sig", "struct _gpgme_key_sig *|_gpgme_key_sig *|gpgme_key_sig_t", 0, 0, (void*)0, 0};
39095 : static swig_type_info _swigt__p__gpgme_new_signature = {"_p__gpgme_new_signature", "struct _gpgme_new_signature *|_gpgme_new_signature *|gpgme_new_signature_t", 0, 0, (void*)0, 0};
39096 : static swig_type_info _swigt__p__gpgme_op_assuan_result = {"_p__gpgme_op_assuan_result", "struct _gpgme_op_assuan_result *|_gpgme_op_assuan_result *", 0, 0, (void*)0, 0};
39097 : static swig_type_info _swigt__p__gpgme_op_decrypt_result = {"_p__gpgme_op_decrypt_result", "struct _gpgme_op_decrypt_result *|_gpgme_op_decrypt_result *|gpgme_decrypt_result_t", 0, 0, (void*)0, 0};
39098 : static swig_type_info _swigt__p__gpgme_op_encrypt_result = {"_p__gpgme_op_encrypt_result", "struct _gpgme_op_encrypt_result *|_gpgme_op_encrypt_result *|gpgme_encrypt_result_t", 0, 0, (void*)0, 0};
39099 : static swig_type_info _swigt__p__gpgme_op_genkey_result = {"_p__gpgme_op_genkey_result", "struct _gpgme_op_genkey_result *|_gpgme_op_genkey_result *|gpgme_genkey_result_t", 0, 0, (void*)0, 0};
39100 : static swig_type_info _swigt__p__gpgme_op_import_result = {"_p__gpgme_op_import_result", "struct _gpgme_op_import_result *|_gpgme_op_import_result *|gpgme_import_result_t", 0, 0, (void*)0, 0};
39101 : static swig_type_info _swigt__p__gpgme_op_keylist_result = {"_p__gpgme_op_keylist_result", "struct _gpgme_op_keylist_result *|_gpgme_op_keylist_result *|gpgme_keylist_result_t", 0, 0, (void*)0, 0};
39102 : static swig_type_info _swigt__p__gpgme_op_query_swdb_result = {"_p__gpgme_op_query_swdb_result", "struct _gpgme_op_query_swdb_result *|_gpgme_op_query_swdb_result *|gpgme_query_swdb_result_t", 0, 0, (void*)0, 0};
39103 : static swig_type_info _swigt__p__gpgme_op_sign_result = {"_p__gpgme_op_sign_result", "struct _gpgme_op_sign_result *|_gpgme_op_sign_result *|gpgme_sign_result_t", 0, 0, (void*)0, 0};
39104 : static swig_type_info _swigt__p__gpgme_op_verify_result = {"_p__gpgme_op_verify_result", "struct _gpgme_op_verify_result *|_gpgme_op_verify_result *|gpgme_verify_result_t", 0, 0, (void*)0, 0};
39105 : static swig_type_info _swigt__p__gpgme_op_vfs_mount_result = {"_p__gpgme_op_vfs_mount_result", "struct _gpgme_op_vfs_mount_result *|_gpgme_op_vfs_mount_result *|gpgme_vfs_mount_result_t", 0, 0, (void*)0, 0};
39106 : static swig_type_info _swigt__p__gpgme_recipient = {"_p__gpgme_recipient", "gpgme_recipient_t|struct _gpgme_recipient *|_gpgme_recipient *", 0, 0, (void*)0, 0};
39107 : static swig_type_info _swigt__p__gpgme_sig_notation = {"_p__gpgme_sig_notation", "struct _gpgme_sig_notation *|_gpgme_sig_notation *|gpgme_sig_notation_t", 0, 0, (void*)0, 0};
39108 : static swig_type_info _swigt__p__gpgme_sig_stat_t = {"_p__gpgme_sig_stat_t", "enum _gpgme_sig_stat_t *|_gpgme_sig_stat_t *", 0, 0, (void*)0, 0};
39109 : static swig_type_info _swigt__p__gpgme_signature = {"_p__gpgme_signature", "struct _gpgme_signature *|_gpgme_signature *|gpgme_signature_t", 0, 0, (void*)0, 0};
39110 : static swig_type_info _swigt__p__gpgme_subkey = {"_p__gpgme_subkey", "struct _gpgme_subkey *|_gpgme_subkey *|gpgme_subkey_t", 0, 0, (void*)0, 0};
39111 : static swig_type_info _swigt__p__gpgme_tofu_info = {"_p__gpgme_tofu_info", "struct _gpgme_tofu_info *|_gpgme_tofu_info *|gpgme_tofu_info_t", 0, 0, (void*)0, 0};
39112 : static swig_type_info _swigt__p__gpgme_trust_item = {"_p__gpgme_trust_item", "gpgme_trust_item_t|struct _gpgme_trust_item *|_gpgme_trust_item *", 0, 0, (void*)0, 0};
39113 : static swig_type_info _swigt__p__gpgme_user_id = {"_p__gpgme_user_id", "struct _gpgme_user_id *|_gpgme_user_id *|gpgme_user_id_t", 0, 0, (void*)0, 0};
39114 : static swig_type_info _swigt__p_a___p__gpgme_key = {"_p_a___p__gpgme_key", "gpgme_key_t (*)[]|struct _gpgme_key *(*)[]", 0, 0, (void*)0, 0};
39115 : static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
39116 : static swig_type_info _swigt__p_f_p_void__void = {"_p_f_p_void__void", "gpgme_remove_io_cb_t|void (*)(void *)|gpgme_data_release_cb_t", 0, 0, (void*)0, 0};
39117 : static swig_type_info _swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void = {"_p_f_p_void_enum_gpgme_event_io_t_p_void__void", "gpgme_event_io_cb_t|void (*)(void *,enum gpgme_event_io_t,void *)", 0, 0, (void*)0, 0};
39118 : static swig_type_info _swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t = {"_p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t", "gpg_error_t (*)(void *,int,int,gpg_error_t (*)(void *,int),void *,void **)|gpgme_register_io_cb_t", 0, 0, (void*)0, 0};
39119 : static swig_type_info _swigt__p_f_p_void_off_t_int__off_t = {"_p_f_p_void_off_t_int__off_t", "off_t (*)(void *,off_t,int)|gpgme_data_seek_cb_t", 0, 0, (void*)0, 0};
39120 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_int_int_int__void = {"_p_f_p_void_p_q_const__char_int_int_int__void", "void (*)(void *,char const *,int,int,int)|gpgme_progress_cb_t", 0, 0, (void*)0, 0};
39121 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *)|gpgme_status_cb_t|gpgme_assuan_status_cb_t", 0, 0, (void*)0, 0};
39122 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t", "gpgme_interact_cb_t|gpg_error_t (*)(void *,char const *,char const *,int)", 0, 0, (void*)0, 0};
39123 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *,int,int)|gpgme_passphrase_cb_t", 0, 0, (void*)0, 0};
39124 : static swig_type_info _swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t = {"_p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t", "gpg_error_t (*)(void *,char const *,char const *,struct gpgme_data **)|gpgme_assuan_inquire_cb_t", 0, 0, (void*)0, 0};
39125 : static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t = {"_p_f_p_void_p_q_const__void_size_t__gpg_error_t", "gpg_error_t (*)(void *,void const *,size_t)|gpgme_assuan_data_cb_t", 0, 0, (void*)0, 0};
39126 : static swig_type_info _swigt__p_f_p_void_p_q_const__void_size_t__ssize_t = {"_p_f_p_void_p_q_const__void_size_t__ssize_t", "ssize_t (*)(void *,void const *,size_t)|gpgme_data_write_cb_t", 0, 0, (void*)0, 0};
39127 : static swig_type_info _swigt__p_f_p_void_p_void_size_t__ssize_t = {"_p_f_p_void_p_void_size_t__ssize_t", "ssize_t (*)(void *,void *,size_t)|gpgme_data_read_cb_t", 0, 0, (void*)0, 0};
39128 : static swig_type_info _swigt__p_gpg_err_code_t = {"_p_gpg_err_code_t", "gpg_err_code_t *|gpgme_err_code_t *", 0, 0, (void*)0, 0};
39129 : static swig_type_info _swigt__p_gpg_err_source_t = {"_p_gpg_err_source_t", "gpg_err_source_t *|gpgme_err_source_t *", 0, 0, (void*)0, 0};
39130 : static swig_type_info _swigt__p_gpg_error_t = {"_p_gpg_error_t", "gpg_error_t *|gpgme_error_t *", 0, 0, (void*)0, 0};
39131 : static swig_type_info _swigt__p_gpgme_conf_arg = {"_p_gpgme_conf_arg", "struct gpgme_conf_arg *|gpgme_conf_arg *|gpgme_conf_arg_t", 0, 0, (void*)0, 0};
39132 : static swig_type_info _swigt__p_gpgme_conf_arg_value = {"_p_gpgme_conf_arg_value", "gpgme_conf_arg_value *", 0, 0, (void*)0, 0};
39133 : static swig_type_info _swigt__p_gpgme_conf_comp = {"_p_gpgme_conf_comp", "struct gpgme_conf_comp *|gpgme_conf_comp *|gpgme_conf_comp_t", 0, 0, (void*)0, 0};
39134 : static swig_type_info _swigt__p_gpgme_conf_level_t = {"_p_gpgme_conf_level_t", "enum gpgme_conf_level_t *|gpgme_conf_level_t *", 0, 0, (void*)0, 0};
39135 : static swig_type_info _swigt__p_gpgme_conf_opt = {"_p_gpgme_conf_opt", "gpgme_conf_opt_t|struct gpgme_conf_opt *|gpgme_conf_opt *", 0, 0, (void*)0, 0};
39136 : static swig_type_info _swigt__p_gpgme_conf_type_t = {"_p_gpgme_conf_type_t", "enum gpgme_conf_type_t *|gpgme_conf_type_t *", 0, 0, (void*)0, 0};
39137 : static swig_type_info _swigt__p_gpgme_context = {"_p_gpgme_context", "gpgme_ctx_t|struct gpgme_context *", 0, 0, (void*)0, 0};
39138 : static swig_type_info _swigt__p_gpgme_data = {"_p_gpgme_data", "struct gpgme_data *|gpgme_data_t", 0, 0, (void*)0, 0};
39139 : static swig_type_info _swigt__p_gpgme_data_cbs = {"_p_gpgme_data_cbs", "gpgme_data_cbs_t|struct gpgme_data_cbs *|gpgme_data_cbs *", 0, 0, (void*)0, 0};
39140 : static swig_type_info _swigt__p_gpgme_data_encoding_t = {"_p_gpgme_data_encoding_t", "enum gpgme_data_encoding_t *|gpgme_data_encoding_t *", 0, 0, (void*)0, 0};
39141 : static swig_type_info _swigt__p_gpgme_data_type_t = {"_p_gpgme_data_type_t", "enum gpgme_data_type_t *|gpgme_data_type_t *", 0, 0, (void*)0, 0};
39142 : static swig_type_info _swigt__p_gpgme_encrypt_flags_t = {"_p_gpgme_encrypt_flags_t", "enum gpgme_encrypt_flags_t *|gpgme_encrypt_flags_t *", 0, 0, (void*)0, 0};
39143 : static swig_type_info _swigt__p_gpgme_event_io_t = {"_p_gpgme_event_io_t", "enum gpgme_event_io_t *|gpgme_event_io_t *", 0, 0, (void*)0, 0};
39144 : static swig_type_info _swigt__p_gpgme_hash_algo_t = {"_p_gpgme_hash_algo_t", "enum gpgme_hash_algo_t *|gpgme_hash_algo_t *", 0, 0, (void*)0, 0};
39145 : static swig_type_info _swigt__p_gpgme_io_cbs = {"_p_gpgme_io_cbs", "gpgme_io_cbs_t|struct gpgme_io_cbs *|gpgme_io_cbs *", 0, 0, (void*)0, 0};
39146 : static swig_type_info _swigt__p_gpgme_io_event_done_data = {"_p_gpgme_io_event_done_data", "struct gpgme_io_event_done_data *|gpgme_io_event_done_data *", 0, 0, (void*)0, 0};
39147 : static swig_type_info _swigt__p_gpgme_pinentry_mode_t = {"_p_gpgme_pinentry_mode_t", "enum gpgme_pinentry_mode_t *|gpgme_pinentry_mode_t *", 0, 0, (void*)0, 0};
39148 : static swig_type_info _swigt__p_gpgme_protocol_t = {"_p_gpgme_protocol_t", "enum gpgme_protocol_t *|gpgme_protocol_t *", 0, 0, (void*)0, 0};
39149 : static swig_type_info _swigt__p_gpgme_pubkey_algo_t = {"_p_gpgme_pubkey_algo_t", "enum gpgme_pubkey_algo_t *|gpgme_pubkey_algo_t *", 0, 0, (void*)0, 0};
39150 : static swig_type_info _swigt__p_gpgme_sig_mode_t = {"_p_gpgme_sig_mode_t", "enum gpgme_sig_mode_t *|gpgme_sig_mode_t *", 0, 0, (void*)0, 0};
39151 : static swig_type_info _swigt__p_gpgme_sigsum_t = {"_p_gpgme_sigsum_t", "enum gpgme_sigsum_t *|gpgme_sigsum_t *", 0, 0, (void*)0, 0};
39152 : static swig_type_info _swigt__p_gpgme_status_code_t = {"_p_gpgme_status_code_t", "enum gpgme_status_code_t *|gpgme_status_code_t *", 0, 0, (void*)0, 0};
39153 : static swig_type_info _swigt__p_gpgme_tofu_policy_t = {"_p_gpgme_tofu_policy_t", "enum gpgme_tofu_policy_t *|gpgme_tofu_policy_t *", 0, 0, (void*)0, 0};
39154 : static swig_type_info _swigt__p_gpgme_validity_t = {"_p_gpgme_validity_t", "enum gpgme_validity_t *|gpgme_validity_t *", 0, 0, (void*)0, 0};
39155 : static swig_type_info _swigt__p_off_t = {"_p_off_t", "off_t *|gpgme_off_t *", 0, 0, (void*)0, 0};
39156 : static swig_type_info _swigt__p_p__gpgme_engine_info = {"_p_p__gpgme_engine_info", "struct _gpgme_engine_info **|gpgme_engine_info_t *", 0, 0, (void*)0, 0};
39157 : static swig_type_info _swigt__p_p__gpgme_key = {"_p_p__gpgme_key", "struct _gpgme_key **|gpgme_key_t *", 0, 0, (void*)0, 0};
39158 : static swig_type_info _swigt__p_p__gpgme_trust_item = {"_p_p__gpgme_trust_item", "struct _gpgme_trust_item **|gpgme_trust_item_t *", 0, 0, (void*)0, 0};
39159 : static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
39160 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_int_int_int__void = {"_p_p_f_p_void_p_q_const__char_int_int_int__void", "void (**)(void *,char const *,int,int,int)|gpgme_progress_cb_t *", 0, 0, (void*)0, 0};
39161 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t = {"_p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t", "gpg_error_t (**)(void *,char const *,char const *)|gpgme_status_cb_t *", 0, 0, (void*)0, 0};
39162 : static swig_type_info _swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t = {"_p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t", "gpg_error_t (**)(void *,char const *,char const *,int,int)|gpgme_passphrase_cb_t *", 0, 0, (void*)0, 0};
39163 : static swig_type_info _swigt__p_p_gpgme_conf_arg = {"_p_p_gpgme_conf_arg", "gpgme_conf_arg_t *|struct gpgme_conf_arg **", 0, 0, (void*)0, 0};
39164 : static swig_type_info _swigt__p_p_gpgme_conf_comp = {"_p_p_gpgme_conf_comp", "struct gpgme_conf_comp **|gpgme_conf_comp_t *", 0, 0, (void*)0, 0};
39165 : static swig_type_info _swigt__p_p_gpgme_conf_opt = {"_p_p_gpgme_conf_opt", "struct gpgme_conf_opt **|gpgme_conf_opt_t *", 0, 0, (void*)0, 0};
39166 : static swig_type_info _swigt__p_p_gpgme_context = {"_p_p_gpgme_context", "gpgme_ctx_t *|struct gpgme_context **", 0, 0, (void*)0, 0};
39167 : static swig_type_info _swigt__p_p_gpgme_data = {"_p_p_gpgme_data", "gpgme_data_t *|struct gpgme_data **", 0, 0, (void*)0, 0};
39168 : static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 0, 0, (void*)0, 0};
39169 : static swig_type_info _swigt__p_size_t = {"_p_size_t", "size_t *", 0, 0, (void*)0, 0};
39170 : static swig_type_info _swigt__p_ssize_t = {"_p_ssize_t", "ssize_t *|gpgme_ssize_t *", 0, 0, (void*)0, 0};
39171 : static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|gpgme_sig_notation_flags_t *|gpgme_keylist_mode_t *|gpgme_export_mode_t *", 0, 0, (void*)0, 0};
39172 : static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
39173 :
39174 : static swig_type_info *swig_type_initial[] = {
39175 : &_swigt__p_FILE,
39176 : &_swigt__p__gpgme_attr_t,
39177 : &_swigt__p__gpgme_engine_info,
39178 : &_swigt__p__gpgme_import_status,
39179 : &_swigt__p__gpgme_invalid_key,
39180 : &_swigt__p__gpgme_key,
39181 : &_swigt__p__gpgme_key_sig,
39182 : &_swigt__p__gpgme_new_signature,
39183 : &_swigt__p__gpgme_op_assuan_result,
39184 : &_swigt__p__gpgme_op_decrypt_result,
39185 : &_swigt__p__gpgme_op_encrypt_result,
39186 : &_swigt__p__gpgme_op_genkey_result,
39187 : &_swigt__p__gpgme_op_import_result,
39188 : &_swigt__p__gpgme_op_keylist_result,
39189 : &_swigt__p__gpgme_op_query_swdb_result,
39190 : &_swigt__p__gpgme_op_sign_result,
39191 : &_swigt__p__gpgme_op_verify_result,
39192 : &_swigt__p__gpgme_op_vfs_mount_result,
39193 : &_swigt__p__gpgme_recipient,
39194 : &_swigt__p__gpgme_sig_notation,
39195 : &_swigt__p__gpgme_sig_stat_t,
39196 : &_swigt__p__gpgme_signature,
39197 : &_swigt__p__gpgme_subkey,
39198 : &_swigt__p__gpgme_tofu_info,
39199 : &_swigt__p__gpgme_trust_item,
39200 : &_swigt__p__gpgme_user_id,
39201 : &_swigt__p_a___p__gpgme_key,
39202 : &_swigt__p_char,
39203 : &_swigt__p_f_p_void__void,
39204 : &_swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
39205 : &_swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
39206 : &_swigt__p_f_p_void_off_t_int__off_t,
39207 : &_swigt__p_f_p_void_p_q_const__char_int_int_int__void,
39208 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
39209 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t,
39210 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
39211 : &_swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
39212 : &_swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
39213 : &_swigt__p_f_p_void_p_q_const__void_size_t__ssize_t,
39214 : &_swigt__p_f_p_void_p_void_size_t__ssize_t,
39215 : &_swigt__p_gpg_err_code_t,
39216 : &_swigt__p_gpg_err_source_t,
39217 : &_swigt__p_gpg_error_t,
39218 : &_swigt__p_gpgme_conf_arg,
39219 : &_swigt__p_gpgme_conf_arg_value,
39220 : &_swigt__p_gpgme_conf_comp,
39221 : &_swigt__p_gpgme_conf_level_t,
39222 : &_swigt__p_gpgme_conf_opt,
39223 : &_swigt__p_gpgme_conf_type_t,
39224 : &_swigt__p_gpgme_context,
39225 : &_swigt__p_gpgme_data,
39226 : &_swigt__p_gpgme_data_cbs,
39227 : &_swigt__p_gpgme_data_encoding_t,
39228 : &_swigt__p_gpgme_data_type_t,
39229 : &_swigt__p_gpgme_encrypt_flags_t,
39230 : &_swigt__p_gpgme_event_io_t,
39231 : &_swigt__p_gpgme_hash_algo_t,
39232 : &_swigt__p_gpgme_io_cbs,
39233 : &_swigt__p_gpgme_io_event_done_data,
39234 : &_swigt__p_gpgme_pinentry_mode_t,
39235 : &_swigt__p_gpgme_protocol_t,
39236 : &_swigt__p_gpgme_pubkey_algo_t,
39237 : &_swigt__p_gpgme_sig_mode_t,
39238 : &_swigt__p_gpgme_sigsum_t,
39239 : &_swigt__p_gpgme_status_code_t,
39240 : &_swigt__p_gpgme_tofu_policy_t,
39241 : &_swigt__p_gpgme_validity_t,
39242 : &_swigt__p_off_t,
39243 : &_swigt__p_p__gpgme_engine_info,
39244 : &_swigt__p_p__gpgme_key,
39245 : &_swigt__p_p__gpgme_trust_item,
39246 : &_swigt__p_p_char,
39247 : &_swigt__p_p_f_p_void_p_q_const__char_int_int_int__void,
39248 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
39249 : &_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
39250 : &_swigt__p_p_gpgme_conf_arg,
39251 : &_swigt__p_p_gpgme_conf_comp,
39252 : &_swigt__p_p_gpgme_conf_opt,
39253 : &_swigt__p_p_gpgme_context,
39254 : &_swigt__p_p_gpgme_data,
39255 : &_swigt__p_p_void,
39256 : &_swigt__p_size_t,
39257 : &_swigt__p_ssize_t,
39258 : &_swigt__p_unsigned_int,
39259 : &_swigt__p_void,
39260 : };
39261 :
39262 : static swig_cast_info _swigc__p_FILE[] = { {&_swigt__p_FILE, 0, 0, 0},{0, 0, 0, 0}};
39263 : static swig_cast_info _swigc__p__gpgme_attr_t[] = { {&_swigt__p__gpgme_attr_t, 0, 0, 0},{0, 0, 0, 0}};
39264 : static swig_cast_info _swigc__p__gpgme_engine_info[] = { {&_swigt__p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
39265 : static swig_cast_info _swigc__p__gpgme_import_status[] = { {&_swigt__p__gpgme_import_status, 0, 0, 0},{0, 0, 0, 0}};
39266 : static swig_cast_info _swigc__p__gpgme_invalid_key[] = { {&_swigt__p__gpgme_invalid_key, 0, 0, 0},{0, 0, 0, 0}};
39267 : static swig_cast_info _swigc__p__gpgme_key[] = { {&_swigt__p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
39268 : static swig_cast_info _swigc__p__gpgme_key_sig[] = { {&_swigt__p__gpgme_key_sig, 0, 0, 0},{0, 0, 0, 0}};
39269 : static swig_cast_info _swigc__p__gpgme_new_signature[] = { {&_swigt__p__gpgme_new_signature, 0, 0, 0},{0, 0, 0, 0}};
39270 : static swig_cast_info _swigc__p__gpgme_op_assuan_result[] = { {&_swigt__p__gpgme_op_assuan_result, 0, 0, 0},{0, 0, 0, 0}};
39271 : static swig_cast_info _swigc__p__gpgme_op_decrypt_result[] = { {&_swigt__p__gpgme_op_decrypt_result, 0, 0, 0},{0, 0, 0, 0}};
39272 : static swig_cast_info _swigc__p__gpgme_op_encrypt_result[] = { {&_swigt__p__gpgme_op_encrypt_result, 0, 0, 0},{0, 0, 0, 0}};
39273 : static swig_cast_info _swigc__p__gpgme_op_genkey_result[] = { {&_swigt__p__gpgme_op_genkey_result, 0, 0, 0},{0, 0, 0, 0}};
39274 : static swig_cast_info _swigc__p__gpgme_op_import_result[] = { {&_swigt__p__gpgme_op_import_result, 0, 0, 0},{0, 0, 0, 0}};
39275 : static swig_cast_info _swigc__p__gpgme_op_keylist_result[] = { {&_swigt__p__gpgme_op_keylist_result, 0, 0, 0},{0, 0, 0, 0}};
39276 : static swig_cast_info _swigc__p__gpgme_op_query_swdb_result[] = { {&_swigt__p__gpgme_op_query_swdb_result, 0, 0, 0},{0, 0, 0, 0}};
39277 : static swig_cast_info _swigc__p__gpgme_op_sign_result[] = { {&_swigt__p__gpgme_op_sign_result, 0, 0, 0},{0, 0, 0, 0}};
39278 : static swig_cast_info _swigc__p__gpgme_op_verify_result[] = { {&_swigt__p__gpgme_op_verify_result, 0, 0, 0},{0, 0, 0, 0}};
39279 : static swig_cast_info _swigc__p__gpgme_op_vfs_mount_result[] = { {&_swigt__p__gpgme_op_vfs_mount_result, 0, 0, 0},{0, 0, 0, 0}};
39280 : static swig_cast_info _swigc__p__gpgme_recipient[] = { {&_swigt__p__gpgme_recipient, 0, 0, 0},{0, 0, 0, 0}};
39281 : static swig_cast_info _swigc__p__gpgme_sig_notation[] = { {&_swigt__p__gpgme_sig_notation, 0, 0, 0},{0, 0, 0, 0}};
39282 : static swig_cast_info _swigc__p__gpgme_sig_stat_t[] = { {&_swigt__p__gpgme_sig_stat_t, 0, 0, 0},{0, 0, 0, 0}};
39283 : static swig_cast_info _swigc__p__gpgme_signature[] = { {&_swigt__p__gpgme_signature, 0, 0, 0},{0, 0, 0, 0}};
39284 : static swig_cast_info _swigc__p__gpgme_subkey[] = { {&_swigt__p__gpgme_subkey, 0, 0, 0},{0, 0, 0, 0}};
39285 : static swig_cast_info _swigc__p__gpgme_tofu_info[] = { {&_swigt__p__gpgme_tofu_info, 0, 0, 0},{0, 0, 0, 0}};
39286 : static swig_cast_info _swigc__p__gpgme_trust_item[] = { {&_swigt__p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
39287 : static swig_cast_info _swigc__p__gpgme_user_id[] = { {&_swigt__p__gpgme_user_id, 0, 0, 0},{0, 0, 0, 0}};
39288 : static swig_cast_info _swigc__p_a___p__gpgme_key[] = { {&_swigt__p_a___p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
39289 : static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
39290 : static swig_cast_info _swigc__p_f_p_void__void[] = { {&_swigt__p_f_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
39291 : static swig_cast_info _swigc__p_f_p_void_enum_gpgme_event_io_t_p_void__void[] = { {&_swigt__p_f_p_void_enum_gpgme_event_io_t_p_void__void, 0, 0, 0},{0, 0, 0, 0}};
39292 : static swig_cast_info _swigc__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t[] = { {&_swigt__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39293 : static swig_cast_info _swigc__p_f_p_void_off_t_int__off_t[] = { {&_swigt__p_f_p_void_off_t_int__off_t, 0, 0, 0},{0, 0, 0, 0}};
39294 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_int_int_int__void[] = { {&_swigt__p_f_p_void_p_q_const__char_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
39295 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39296 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39297 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39298 : static swig_cast_info _swigc__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39299 : static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__gpg_error_t[] = { {&_swigt__p_f_p_void_p_q_const__void_size_t__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39300 : static swig_cast_info _swigc__p_f_p_void_p_q_const__void_size_t__ssize_t[] = { {&_swigt__p_f_p_void_p_q_const__void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
39301 : static swig_cast_info _swigc__p_f_p_void_p_void_size_t__ssize_t[] = { {&_swigt__p_f_p_void_p_void_size_t__ssize_t, 0, 0, 0},{0, 0, 0, 0}};
39302 : static swig_cast_info _swigc__p_gpg_err_code_t[] = { {&_swigt__p_gpg_err_code_t, 0, 0, 0},{0, 0, 0, 0}};
39303 : static swig_cast_info _swigc__p_gpg_err_source_t[] = { {&_swigt__p_gpg_err_source_t, 0, 0, 0},{0, 0, 0, 0}};
39304 : static swig_cast_info _swigc__p_gpg_error_t[] = { {&_swigt__p_gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39305 : static swig_cast_info _swigc__p_gpgme_conf_arg[] = { {&_swigt__p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
39306 : static swig_cast_info _swigc__p_gpgme_conf_arg_value[] = { {&_swigt__p_gpgme_conf_arg_value, 0, 0, 0},{0, 0, 0, 0}};
39307 : static swig_cast_info _swigc__p_gpgme_conf_comp[] = { {&_swigt__p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
39308 : static swig_cast_info _swigc__p_gpgme_conf_level_t[] = { {&_swigt__p_gpgme_conf_level_t, 0, 0, 0},{0, 0, 0, 0}};
39309 : static swig_cast_info _swigc__p_gpgme_conf_opt[] = { {&_swigt__p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
39310 : static swig_cast_info _swigc__p_gpgme_conf_type_t[] = { {&_swigt__p_gpgme_conf_type_t, 0, 0, 0},{0, 0, 0, 0}};
39311 : static swig_cast_info _swigc__p_gpgme_context[] = { {&_swigt__p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
39312 : static swig_cast_info _swigc__p_gpgme_data[] = { {&_swigt__p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
39313 : static swig_cast_info _swigc__p_gpgme_data_cbs[] = { {&_swigt__p_gpgme_data_cbs, 0, 0, 0},{0, 0, 0, 0}};
39314 : static swig_cast_info _swigc__p_gpgme_data_encoding_t[] = { {&_swigt__p_gpgme_data_encoding_t, 0, 0, 0},{0, 0, 0, 0}};
39315 : static swig_cast_info _swigc__p_gpgme_data_type_t[] = { {&_swigt__p_gpgme_data_type_t, 0, 0, 0},{0, 0, 0, 0}};
39316 : static swig_cast_info _swigc__p_gpgme_encrypt_flags_t[] = { {&_swigt__p_gpgme_encrypt_flags_t, 0, 0, 0},{0, 0, 0, 0}};
39317 : static swig_cast_info _swigc__p_gpgme_event_io_t[] = { {&_swigt__p_gpgme_event_io_t, 0, 0, 0},{0, 0, 0, 0}};
39318 : static swig_cast_info _swigc__p_gpgme_hash_algo_t[] = { {&_swigt__p_gpgme_hash_algo_t, 0, 0, 0},{0, 0, 0, 0}};
39319 : static swig_cast_info _swigc__p_gpgme_io_cbs[] = { {&_swigt__p_gpgme_io_cbs, 0, 0, 0},{0, 0, 0, 0}};
39320 : static swig_cast_info _swigc__p_gpgme_io_event_done_data[] = { {&_swigt__p_gpgme_io_event_done_data, 0, 0, 0},{0, 0, 0, 0}};
39321 : static swig_cast_info _swigc__p_gpgme_pinentry_mode_t[] = { {&_swigt__p_gpgme_pinentry_mode_t, 0, 0, 0},{0, 0, 0, 0}};
39322 : static swig_cast_info _swigc__p_gpgme_protocol_t[] = { {&_swigt__p_gpgme_protocol_t, 0, 0, 0},{0, 0, 0, 0}};
39323 : static swig_cast_info _swigc__p_gpgme_pubkey_algo_t[] = { {&_swigt__p_gpgme_pubkey_algo_t, 0, 0, 0},{0, 0, 0, 0}};
39324 : static swig_cast_info _swigc__p_gpgme_sig_mode_t[] = { {&_swigt__p_gpgme_sig_mode_t, 0, 0, 0},{0, 0, 0, 0}};
39325 : static swig_cast_info _swigc__p_gpgme_sigsum_t[] = { {&_swigt__p_gpgme_sigsum_t, 0, 0, 0},{0, 0, 0, 0}};
39326 : static swig_cast_info _swigc__p_gpgme_status_code_t[] = { {&_swigt__p_gpgme_status_code_t, 0, 0, 0},{0, 0, 0, 0}};
39327 : static swig_cast_info _swigc__p_gpgme_tofu_policy_t[] = { {&_swigt__p_gpgme_tofu_policy_t, 0, 0, 0},{0, 0, 0, 0}};
39328 : static swig_cast_info _swigc__p_gpgme_validity_t[] = { {&_swigt__p_gpgme_validity_t, 0, 0, 0},{0, 0, 0, 0}};
39329 : static swig_cast_info _swigc__p_off_t[] = { {&_swigt__p_off_t, 0, 0, 0},{0, 0, 0, 0}};
39330 : static swig_cast_info _swigc__p_p__gpgme_engine_info[] = { {&_swigt__p_p__gpgme_engine_info, 0, 0, 0},{0, 0, 0, 0}};
39331 : static swig_cast_info _swigc__p_p__gpgme_key[] = { {&_swigt__p_p__gpgme_key, 0, 0, 0},{0, 0, 0, 0}};
39332 : static swig_cast_info _swigc__p_p__gpgme_trust_item[] = { {&_swigt__p_p__gpgme_trust_item, 0, 0, 0},{0, 0, 0, 0}};
39333 : static swig_cast_info _swigc__p_p_char[] = { {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
39334 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_int_int_int__void[] = { {&_swigt__p_p_f_p_void_p_q_const__char_int_int_int__void, 0, 0, 0},{0, 0, 0, 0}};
39335 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39336 : static swig_cast_info _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t[] = { {&_swigt__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t, 0, 0, 0},{0, 0, 0, 0}};
39337 : static swig_cast_info _swigc__p_p_gpgme_conf_arg[] = { {&_swigt__p_p_gpgme_conf_arg, 0, 0, 0},{0, 0, 0, 0}};
39338 : static swig_cast_info _swigc__p_p_gpgme_conf_comp[] = { {&_swigt__p_p_gpgme_conf_comp, 0, 0, 0},{0, 0, 0, 0}};
39339 : static swig_cast_info _swigc__p_p_gpgme_conf_opt[] = { {&_swigt__p_p_gpgme_conf_opt, 0, 0, 0},{0, 0, 0, 0}};
39340 : static swig_cast_info _swigc__p_p_gpgme_context[] = { {&_swigt__p_p_gpgme_context, 0, 0, 0},{0, 0, 0, 0}};
39341 : static swig_cast_info _swigc__p_p_gpgme_data[] = { {&_swigt__p_p_gpgme_data, 0, 0, 0},{0, 0, 0, 0}};
39342 : static swig_cast_info _swigc__p_p_void[] = { {&_swigt__p_p_void, 0, 0, 0},{0, 0, 0, 0}};
39343 : static swig_cast_info _swigc__p_size_t[] = { {&_swigt__p_size_t, 0, 0, 0},{0, 0, 0, 0}};
39344 : static swig_cast_info _swigc__p_ssize_t[] = { {&_swigt__p_ssize_t, 0, 0, 0},{0, 0, 0, 0}};
39345 : static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
39346 : static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
39347 :
39348 : static swig_cast_info *swig_cast_initial[] = {
39349 : _swigc__p_FILE,
39350 : _swigc__p__gpgme_attr_t,
39351 : _swigc__p__gpgme_engine_info,
39352 : _swigc__p__gpgme_import_status,
39353 : _swigc__p__gpgme_invalid_key,
39354 : _swigc__p__gpgme_key,
39355 : _swigc__p__gpgme_key_sig,
39356 : _swigc__p__gpgme_new_signature,
39357 : _swigc__p__gpgme_op_assuan_result,
39358 : _swigc__p__gpgme_op_decrypt_result,
39359 : _swigc__p__gpgme_op_encrypt_result,
39360 : _swigc__p__gpgme_op_genkey_result,
39361 : _swigc__p__gpgme_op_import_result,
39362 : _swigc__p__gpgme_op_keylist_result,
39363 : _swigc__p__gpgme_op_query_swdb_result,
39364 : _swigc__p__gpgme_op_sign_result,
39365 : _swigc__p__gpgme_op_verify_result,
39366 : _swigc__p__gpgme_op_vfs_mount_result,
39367 : _swigc__p__gpgme_recipient,
39368 : _swigc__p__gpgme_sig_notation,
39369 : _swigc__p__gpgme_sig_stat_t,
39370 : _swigc__p__gpgme_signature,
39371 : _swigc__p__gpgme_subkey,
39372 : _swigc__p__gpgme_tofu_info,
39373 : _swigc__p__gpgme_trust_item,
39374 : _swigc__p__gpgme_user_id,
39375 : _swigc__p_a___p__gpgme_key,
39376 : _swigc__p_char,
39377 : _swigc__p_f_p_void__void,
39378 : _swigc__p_f_p_void_enum_gpgme_event_io_t_p_void__void,
39379 : _swigc__p_f_p_void_int_int_p_f_p_void_int__gpg_error_t_p_void_p_p_void__gpg_error_t,
39380 : _swigc__p_f_p_void_off_t_int__off_t,
39381 : _swigc__p_f_p_void_p_q_const__char_int_int_int__void,
39382 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
39383 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int__gpg_error_t,
39384 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
39385 : _swigc__p_f_p_void_p_q_const__char_p_q_const__char_p_p_struct_gpgme_data__gpg_error_t,
39386 : _swigc__p_f_p_void_p_q_const__void_size_t__gpg_error_t,
39387 : _swigc__p_f_p_void_p_q_const__void_size_t__ssize_t,
39388 : _swigc__p_f_p_void_p_void_size_t__ssize_t,
39389 : _swigc__p_gpg_err_code_t,
39390 : _swigc__p_gpg_err_source_t,
39391 : _swigc__p_gpg_error_t,
39392 : _swigc__p_gpgme_conf_arg,
39393 : _swigc__p_gpgme_conf_arg_value,
39394 : _swigc__p_gpgme_conf_comp,
39395 : _swigc__p_gpgme_conf_level_t,
39396 : _swigc__p_gpgme_conf_opt,
39397 : _swigc__p_gpgme_conf_type_t,
39398 : _swigc__p_gpgme_context,
39399 : _swigc__p_gpgme_data,
39400 : _swigc__p_gpgme_data_cbs,
39401 : _swigc__p_gpgme_data_encoding_t,
39402 : _swigc__p_gpgme_data_type_t,
39403 : _swigc__p_gpgme_encrypt_flags_t,
39404 : _swigc__p_gpgme_event_io_t,
39405 : _swigc__p_gpgme_hash_algo_t,
39406 : _swigc__p_gpgme_io_cbs,
39407 : _swigc__p_gpgme_io_event_done_data,
39408 : _swigc__p_gpgme_pinentry_mode_t,
39409 : _swigc__p_gpgme_protocol_t,
39410 : _swigc__p_gpgme_pubkey_algo_t,
39411 : _swigc__p_gpgme_sig_mode_t,
39412 : _swigc__p_gpgme_sigsum_t,
39413 : _swigc__p_gpgme_status_code_t,
39414 : _swigc__p_gpgme_tofu_policy_t,
39415 : _swigc__p_gpgme_validity_t,
39416 : _swigc__p_off_t,
39417 : _swigc__p_p__gpgme_engine_info,
39418 : _swigc__p_p__gpgme_key,
39419 : _swigc__p_p__gpgme_trust_item,
39420 : _swigc__p_p_char,
39421 : _swigc__p_p_f_p_void_p_q_const__char_int_int_int__void,
39422 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char__gpg_error_t,
39423 : _swigc__p_p_f_p_void_p_q_const__char_p_q_const__char_int_int__gpg_error_t,
39424 : _swigc__p_p_gpgme_conf_arg,
39425 : _swigc__p_p_gpgme_conf_comp,
39426 : _swigc__p_p_gpgme_conf_opt,
39427 : _swigc__p_p_gpgme_context,
39428 : _swigc__p_p_gpgme_data,
39429 : _swigc__p_p_void,
39430 : _swigc__p_size_t,
39431 : _swigc__p_ssize_t,
39432 : _swigc__p_unsigned_int,
39433 : _swigc__p_void,
39434 : };
39435 :
39436 :
39437 : /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
39438 :
39439 : static swig_const_info swig_const_table[] = {
39440 : {0, 0, 0, 0.0, 0, 0}};
39441 :
39442 : #ifdef __cplusplus
39443 : }
39444 : #endif
39445 : /* -----------------------------------------------------------------------------
39446 : * Type initialization:
39447 : * This problem is tough by the requirement that no dynamic
39448 : * memory is used. Also, since swig_type_info structures store pointers to
39449 : * swig_cast_info structures and swig_cast_info structures store pointers back
39450 : * to swig_type_info structures, we need some lookup code at initialization.
39451 : * The idea is that swig generates all the structures that are needed.
39452 : * The runtime then collects these partially filled structures.
39453 : * The SWIG_InitializeModule function takes these initial arrays out of
39454 : * swig_module, and does all the lookup, filling in the swig_module.types
39455 : * array with the correct data and linking the correct swig_cast_info
39456 : * structures together.
39457 : *
39458 : * The generated swig_type_info structures are assigned statically to an initial
39459 : * array. We just loop through that array, and handle each type individually.
39460 : * First we lookup if this type has been already loaded, and if so, use the
39461 : * loaded structure instead of the generated one. Then we have to fill in the
39462 : * cast linked list. The cast data is initially stored in something like a
39463 : * two-dimensional array. Each row corresponds to a type (there are the same
39464 : * number of rows as there are in the swig_type_initial array). Each entry in
39465 : * a column is one of the swig_cast_info structures for that type.
39466 : * The cast_initial array is actually an array of arrays, because each row has
39467 : * a variable number of columns. So to actually build the cast linked list,
39468 : * we find the array of casts associated with the type, and loop through it
39469 : * adding the casts to the list. The one last trick we need to do is making
39470 : * sure the type pointer in the swig_cast_info struct is correct.
39471 : *
39472 : * First off, we lookup the cast->type name to see if it is already loaded.
39473 : * There are three cases to handle:
39474 : * 1) If the cast->type has already been loaded AND the type we are adding
39475 : * casting info to has not been loaded (it is in this module), THEN we
39476 : * replace the cast->type pointer with the type pointer that has already
39477 : * been loaded.
39478 : * 2) If BOTH types (the one we are adding casting info to, and the
39479 : * cast->type) are loaded, THEN the cast info has already been loaded by
39480 : * the previous module so we just ignore it.
39481 : * 3) Finally, if cast->type has not already been loaded, then we add that
39482 : * swig_cast_info to the linked list (because the cast->type) pointer will
39483 : * be correct.
39484 : * ----------------------------------------------------------------------------- */
39485 :
39486 : #ifdef __cplusplus
39487 : extern "C" {
39488 : #if 0
39489 : } /* c-mode */
39490 : #endif
39491 : #endif
39492 :
39493 : #if 0
39494 : #define SWIGRUNTIME_DEBUG
39495 : #endif
39496 :
39497 :
39498 : SWIGRUNTIME void
39499 27 : SWIG_InitializeModule(void *clientdata) {
39500 : size_t i;
39501 : swig_module_info *module_head, *iter;
39502 : int init;
39503 :
39504 : /* check to see if the circular list has been setup, if not, set it up */
39505 27 : if (swig_module.next==0) {
39506 : /* Initialize the swig_module */
39507 27 : swig_module.type_initial = swig_type_initial;
39508 27 : swig_module.cast_initial = swig_cast_initial;
39509 27 : swig_module.next = &swig_module;
39510 27 : init = 1;
39511 : } else {
39512 : init = 0;
39513 : }
39514 :
39515 : /* Try and load any already created modules */
39516 27 : module_head = SWIG_GetModule(clientdata);
39517 27 : if (!module_head) {
39518 : /* This is the first module loaded for this interpreter */
39519 : /* so set the swig module into the interpreter */
39520 27 : SWIG_SetModule(clientdata, &swig_module);
39521 : } else {
39522 : /* the interpreter has loaded a SWIG module, but has it loaded this one? */
39523 : iter=module_head;
39524 : do {
39525 0 : if (iter==&swig_module) {
39526 : /* Our module is already in the list, so there's nothing more to do. */
39527 : return;
39528 : }
39529 0 : iter=iter->next;
39530 0 : } while (iter!= module_head);
39531 :
39532 : /* otherwise we must add our module into the list */
39533 0 : swig_module.next = module_head->next;
39534 0 : module_head->next = &swig_module;
39535 : }
39536 :
39537 : /* When multiple interpreters are used, a module could have already been initialized in
39538 : a different interpreter, but not yet have a pointer in this interpreter.
39539 : In this case, we do not want to continue adding types... everything should be
39540 : set up already */
39541 27 : if (init == 0) return;
39542 :
39543 : /* Now work on filling in swig_module.types */
39544 : #ifdef SWIGRUNTIME_DEBUG
39545 : printf("SWIG_InitializeModule: size %d\n", swig_module.size);
39546 : #endif
39547 2295 : for (i = 0; i < swig_module.size; ++i) {
39548 2295 : swig_type_info *type = 0;
39549 : swig_type_info *ret;
39550 : swig_cast_info *cast;
39551 :
39552 : #ifdef SWIGRUNTIME_DEBUG
39553 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39554 : #endif
39555 :
39556 : /* if there is another module already loaded */
39557 2295 : if (swig_module.next != &swig_module) {
39558 0 : type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
39559 : }
39560 2295 : if (type) {
39561 : /* Overwrite clientdata field */
39562 : #ifdef SWIGRUNTIME_DEBUG
39563 : printf("SWIG_InitializeModule: found type %s\n", type->name);
39564 : #endif
39565 0 : if (swig_module.type_initial[i]->clientdata) {
39566 0 : type->clientdata = swig_module.type_initial[i]->clientdata;
39567 : #ifdef SWIGRUNTIME_DEBUG
39568 : printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
39569 : #endif
39570 : }
39571 : } else {
39572 2295 : type = swig_module.type_initial[i];
39573 : }
39574 :
39575 : /* Insert casting types */
39576 2295 : cast = swig_module.cast_initial[i];
39577 4590 : while (cast->type) {
39578 : /* Don't need to add information already in the list */
39579 2295 : ret = 0;
39580 : #ifdef SWIGRUNTIME_DEBUG
39581 : printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
39582 : #endif
39583 2295 : if (swig_module.next != &swig_module) {
39584 0 : ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
39585 : #ifdef SWIGRUNTIME_DEBUG
39586 : if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
39587 : #endif
39588 : }
39589 2295 : if (ret) {
39590 0 : if (type == swig_module.type_initial[i]) {
39591 : #ifdef SWIGRUNTIME_DEBUG
39592 : printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
39593 : #endif
39594 0 : cast->type = ret;
39595 0 : ret = 0;
39596 : } else {
39597 : /* Check for casting already in the list */
39598 0 : swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
39599 : #ifdef SWIGRUNTIME_DEBUG
39600 : if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
39601 : #endif
39602 0 : if (!ocast) ret = 0;
39603 : }
39604 : }
39605 :
39606 2295 : if (!ret) {
39607 : #ifdef SWIGRUNTIME_DEBUG
39608 : printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
39609 : #endif
39610 2295 : if (type->cast) {
39611 0 : type->cast->prev = cast;
39612 0 : cast->next = type->cast;
39613 : }
39614 2295 : type->cast = cast;
39615 : }
39616 2295 : cast++;
39617 : }
39618 : /* Set entry in modules->types array equal to the type */
39619 2295 : swig_module.types[i] = type;
39620 : }
39621 27 : swig_module.types[i] = 0;
39622 :
39623 : #ifdef SWIGRUNTIME_DEBUG
39624 : printf("**** SWIG_InitializeModule: Cast List ******\n");
39625 : for (i = 0; i < swig_module.size; ++i) {
39626 : int j = 0;
39627 : swig_cast_info *cast = swig_module.cast_initial[i];
39628 : printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
39629 : while (cast->type) {
39630 : printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
39631 : cast++;
39632 : ++j;
39633 : }
39634 : printf("---- Total casts: %d\n",j);
39635 : }
39636 : printf("**** SWIG_InitializeModule: Cast List ******\n");
39637 : #endif
39638 : }
39639 :
39640 : /* This function will propagate the clientdata field of type to
39641 : * any new swig_type_info structures that have been added into the list
39642 : * of equivalent types. It is like calling
39643 : * SWIG_TypeClientData(type, clientdata) a second time.
39644 : */
39645 : SWIGRUNTIME void
39646 : SWIG_PropagateClientData(void) {
39647 : size_t i;
39648 : swig_cast_info *equiv;
39649 : static int init_run = 0;
39650 :
39651 : if (init_run) return;
39652 : init_run = 1;
39653 :
39654 : for (i = 0; i < swig_module.size; i++) {
39655 : if (swig_module.types[i]->clientdata) {
39656 : equiv = swig_module.types[i]->cast;
39657 : while (equiv) {
39658 : if (!equiv->converter) {
39659 : if (equiv->type && !equiv->type->clientdata)
39660 : SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
39661 : }
39662 : equiv = equiv->next;
39663 : }
39664 : }
39665 : }
39666 : }
39667 :
39668 : #ifdef __cplusplus
39669 : #if 0
39670 : {
39671 : /* c-mode */
39672 : #endif
39673 : }
39674 : #endif
39675 :
39676 :
39677 :
39678 : #ifdef __cplusplus
39679 : extern "C" {
39680 : #endif
39681 :
39682 : /* Python-specific SWIG API */
39683 : #define SWIG_newvarlink() SWIG_Python_newvarlink()
39684 : #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
39685 : #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
39686 :
39687 : /* -----------------------------------------------------------------------------
39688 : * global variable support code.
39689 : * ----------------------------------------------------------------------------- */
39690 :
39691 : typedef struct swig_globalvar {
39692 : char *name; /* Name of global variable */
39693 : PyObject *(*get_attr)(void); /* Return the current value */
39694 : int (*set_attr)(PyObject *); /* Set the value */
39695 : struct swig_globalvar *next;
39696 : } swig_globalvar;
39697 :
39698 : typedef struct swig_varlinkobject {
39699 : PyObject_HEAD
39700 : swig_globalvar *vars;
39701 : } swig_varlinkobject;
39702 :
39703 : SWIGINTERN PyObject *
39704 0 : swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
39705 : #if PY_VERSION_HEX >= 0x03000000
39706 : return PyUnicode_InternFromString("<Swig global variables>");
39707 : #else
39708 0 : return PyString_FromString("<Swig global variables>");
39709 : #endif
39710 : }
39711 :
39712 : SWIGINTERN PyObject *
39713 0 : swig_varlink_str(swig_varlinkobject *v) {
39714 : #if PY_VERSION_HEX >= 0x03000000
39715 : PyObject *str = PyUnicode_InternFromString("(");
39716 : PyObject *tail;
39717 : PyObject *joined;
39718 : swig_globalvar *var;
39719 : for (var = v->vars; var; var=var->next) {
39720 : tail = PyUnicode_FromString(var->name);
39721 : joined = PyUnicode_Concat(str, tail);
39722 : Py_DecRef(str);
39723 : Py_DecRef(tail);
39724 : str = joined;
39725 : if (var->next) {
39726 : tail = PyUnicode_InternFromString(", ");
39727 : joined = PyUnicode_Concat(str, tail);
39728 : Py_DecRef(str);
39729 : Py_DecRef(tail);
39730 : str = joined;
39731 : }
39732 : }
39733 : tail = PyUnicode_InternFromString(")");
39734 : joined = PyUnicode_Concat(str, tail);
39735 : Py_DecRef(str);
39736 : Py_DecRef(tail);
39737 : str = joined;
39738 : #else
39739 0 : PyObject *str = PyString_FromString("(");
39740 : swig_globalvar *var;
39741 0 : for (var = v->vars; var; var=var->next) {
39742 0 : PyString_ConcatAndDel(&str,PyString_FromString(var->name));
39743 0 : if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
39744 : }
39745 0 : PyString_ConcatAndDel(&str,PyString_FromString(")"));
39746 : #endif
39747 0 : return str;
39748 : }
39749 :
39750 : SWIGINTERN int
39751 0 : swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
39752 : char *tmp;
39753 0 : PyObject *str = swig_varlink_str(v);
39754 0 : fprintf(fp,"Swig global variables ");
39755 0 : fprintf(fp,"%s\n", tmp = SWIG_Python_str_AsChar(str));
39756 : SWIG_Python_str_DelForPy3(tmp);
39757 0 : Py_DECREF(str);
39758 0 : return 0;
39759 : }
39760 :
39761 : SWIGINTERN void
39762 0 : swig_varlink_dealloc(swig_varlinkobject *v) {
39763 0 : swig_globalvar *var = v->vars;
39764 0 : while (var) {
39765 0 : swig_globalvar *n = var->next;
39766 0 : free(var->name);
39767 0 : free(var);
39768 0 : var = n;
39769 : }
39770 0 : }
39771 :
39772 : SWIGINTERN PyObject *
39773 27 : swig_varlink_getattr(swig_varlinkobject *v, char *n) {
39774 27 : PyObject *res = NULL;
39775 27 : swig_globalvar *var = v->vars;
39776 54 : while (var) {
39777 27 : if (strcmp(var->name,n) == 0) {
39778 27 : res = (*var->get_attr)();
39779 27 : break;
39780 : }
39781 0 : var = var->next;
39782 : }
39783 27 : if (res == NULL && !PyErr_Occurred()) {
39784 0 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
39785 : }
39786 27 : return res;
39787 : }
39788 :
39789 : SWIGINTERN int
39790 0 : swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
39791 0 : int res = 1;
39792 0 : swig_globalvar *var = v->vars;
39793 0 : while (var) {
39794 0 : if (strcmp(var->name,n) == 0) {
39795 0 : res = (*var->set_attr)(p);
39796 0 : break;
39797 : }
39798 0 : var = var->next;
39799 : }
39800 0 : if (res == 1 && !PyErr_Occurred()) {
39801 0 : PyErr_Format(PyExc_AttributeError, "Unknown C global variable '%s'", n);
39802 : }
39803 0 : return res;
39804 : }
39805 :
39806 : SWIGINTERN PyTypeObject*
39807 54 : swig_varlink_type(void) {
39808 : static char varlink__doc__[] = "Swig var link object";
39809 : static PyTypeObject varlink_type;
39810 : static int type_init = 0;
39811 54 : if (!type_init) {
39812 : const PyTypeObject tmp = {
39813 : /* PyObject header changed in Python 3 */
39814 : #if PY_VERSION_HEX >= 0x03000000
39815 : PyVarObject_HEAD_INIT(NULL, 0)
39816 : #else
39817 : PyObject_HEAD_INIT(NULL)
39818 : 0, /* ob_size */
39819 : #endif
39820 : (char *)"swigvarlink", /* tp_name */
39821 : sizeof(swig_varlinkobject), /* tp_basicsize */
39822 : 0, /* tp_itemsize */
39823 : (destructor) swig_varlink_dealloc, /* tp_dealloc */
39824 : (printfunc) swig_varlink_print, /* tp_print */
39825 : (getattrfunc) swig_varlink_getattr, /* tp_getattr */
39826 : (setattrfunc) swig_varlink_setattr, /* tp_setattr */
39827 : 0, /* tp_compare */
39828 : (reprfunc) swig_varlink_repr, /* tp_repr */
39829 : 0, /* tp_as_number */
39830 : 0, /* tp_as_sequence */
39831 : 0, /* tp_as_mapping */
39832 : 0, /* tp_hash */
39833 : 0, /* tp_call */
39834 : (reprfunc) swig_varlink_str, /* tp_str */
39835 : 0, /* tp_getattro */
39836 : 0, /* tp_setattro */
39837 : 0, /* tp_as_buffer */
39838 : 0, /* tp_flags */
39839 : varlink__doc__, /* tp_doc */
39840 : 0, /* tp_traverse */
39841 : 0, /* tp_clear */
39842 : 0, /* tp_richcompare */
39843 : 0, /* tp_weaklistoffset */
39844 : #if PY_VERSION_HEX >= 0x02020000
39845 : 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
39846 : #endif
39847 : #if PY_VERSION_HEX >= 0x02030000
39848 : 0, /* tp_del */
39849 : #endif
39850 : #if PY_VERSION_HEX >= 0x02060000
39851 : 0, /* tp_version_tag */
39852 : #endif
39853 : #if PY_VERSION_HEX >= 0x03040000
39854 : 0, /* tp_finalize */
39855 : #endif
39856 : #ifdef COUNT_ALLOCS
39857 : 0, /* tp_allocs */
39858 : 0, /* tp_frees */
39859 : 0, /* tp_maxalloc */
39860 : #if PY_VERSION_HEX >= 0x02050000
39861 : 0, /* tp_prev */
39862 : #endif
39863 : 0 /* tp_next */
39864 : #endif
39865 : };
39866 27 : varlink_type = tmp;
39867 27 : type_init = 1;
39868 : #if PY_VERSION_HEX < 0x02020000
39869 : varlink_type.ob_type = &PyType_Type;
39870 : #else
39871 27 : if (PyType_Ready(&varlink_type) < 0)
39872 : return NULL;
39873 : #endif
39874 : }
39875 : return &varlink_type;
39876 : }
39877 :
39878 : /* Create a variable linking object for use later */
39879 : SWIGINTERN PyObject *
39880 27 : SWIG_Python_newvarlink(void) {
39881 27 : swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
39882 27 : if (result) {
39883 27 : result->vars = 0;
39884 : }
39885 27 : return ((PyObject*) result);
39886 : }
39887 :
39888 : SWIGINTERN void
39889 27 : SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
39890 27 : swig_varlinkobject *v = (swig_varlinkobject *) p;
39891 27 : swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
39892 27 : if (gv) {
39893 27 : size_t size = strlen(name)+1;
39894 27 : gv->name = (char *)malloc(size);
39895 27 : if (gv->name) {
39896 27 : strncpy(gv->name,name,size);
39897 27 : gv->get_attr = get_attr;
39898 27 : gv->set_attr = set_attr;
39899 27 : gv->next = v->vars;
39900 : }
39901 : }
39902 27 : v->vars = gv;
39903 27 : }
39904 :
39905 : SWIGINTERN PyObject *
39906 : SWIG_globals(void) {
39907 : static PyObject *_SWIG_globals = 0;
39908 54 : if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
39909 54 : return _SWIG_globals;
39910 : }
39911 :
39912 : /* -----------------------------------------------------------------------------
39913 : * constants/methods manipulation
39914 : * ----------------------------------------------------------------------------- */
39915 :
39916 : /* Install Constants */
39917 : SWIGINTERN void
39918 27 : SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
39919 27 : PyObject *obj = 0;
39920 : size_t i;
39921 27 : for (i = 0; constants[i].type; ++i) {
39922 0 : switch(constants[i].type) {
39923 : case SWIG_PY_POINTER:
39924 0 : obj = SWIG_InternalNewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
39925 0 : break;
39926 : case SWIG_PY_BINARY:
39927 0 : obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
39928 : break;
39929 : default:
39930 : obj = 0;
39931 : break;
39932 : }
39933 0 : if (obj) {
39934 0 : PyDict_SetItemString(d, constants[i].name, obj);
39935 0 : Py_DECREF(obj);
39936 : }
39937 : }
39938 27 : }
39939 :
39940 : /* -----------------------------------------------------------------------------*/
39941 : /* Fix SwigMethods to carry the callback ptrs when needed */
39942 : /* -----------------------------------------------------------------------------*/
39943 :
39944 : SWIGINTERN void
39945 27 : SWIG_Python_FixMethods(PyMethodDef *methods,
39946 : swig_const_info *const_table,
39947 : swig_type_info **types,
39948 : swig_type_info **types_initial) {
39949 : size_t i;
39950 20250 : for (i = 0; methods[i].ml_name; ++i) {
39951 20223 : const char *c = methods[i].ml_doc;
39952 20223 : if (!c) continue;
39953 19386 : c = strstr(c, "swig_ptr: ");
39954 19386 : if (c) {
39955 : int j;
39956 0 : swig_const_info *ci = 0;
39957 0 : const char *name = c + 10;
39958 0 : for (j = 0; const_table[j].type; ++j) {
39959 0 : if (strncmp(const_table[j].name, name,
39960 : strlen(const_table[j].name)) == 0) {
39961 : ci = &(const_table[j]);
39962 : break;
39963 : }
39964 : }
39965 0 : if (ci) {
39966 0 : void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
39967 0 : if (ptr) {
39968 0 : size_t shift = (ci->ptype) - types;
39969 0 : swig_type_info *ty = types_initial[shift];
39970 0 : size_t ldoc = (c - methods[i].ml_doc);
39971 0 : size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
39972 0 : char *ndoc = (char*)malloc(ldoc + lptr + 10);
39973 0 : if (ndoc) {
39974 0 : char *buff = ndoc;
39975 0 : strncpy(buff, methods[i].ml_doc, ldoc);
39976 0 : buff += ldoc;
39977 0 : strncpy(buff, "swig_ptr: ", 10);
39978 0 : buff += 10;
39979 0 : SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
39980 0 : methods[i].ml_doc = ndoc;
39981 : }
39982 : }
39983 : }
39984 : }
39985 : }
39986 27 : }
39987 :
39988 : #ifdef __cplusplus
39989 : }
39990 : #endif
39991 :
39992 : /* -----------------------------------------------------------------------------*
39993 : * Partial Init method
39994 : * -----------------------------------------------------------------------------*/
39995 :
39996 : #ifdef __cplusplus
39997 : extern "C"
39998 : #endif
39999 :
40000 : SWIGEXPORT
40001 : #if PY_VERSION_HEX >= 0x03000000
40002 : PyObject*
40003 : #else
40004 : void
40005 : #endif
40006 27 : SWIG_init(void) {
40007 : PyObject *m, *d, *md;
40008 : #if PY_VERSION_HEX >= 0x03000000
40009 : static struct PyModuleDef SWIG_module = {
40010 : # if PY_VERSION_HEX >= 0x03020000
40011 : PyModuleDef_HEAD_INIT,
40012 : # else
40013 : {
40014 : PyObject_HEAD_INIT(NULL)
40015 : NULL, /* m_init */
40016 : 0, /* m_index */
40017 : NULL, /* m_copy */
40018 : },
40019 : # endif
40020 : (char *) SWIG_name,
40021 : NULL,
40022 : -1,
40023 : SwigMethods,
40024 : NULL,
40025 : NULL,
40026 : NULL,
40027 : NULL
40028 : };
40029 : #endif
40030 :
40031 : #if defined(SWIGPYTHON_BUILTIN)
40032 : static SwigPyClientData SwigPyObject_clientdata = {
40033 : 0, 0, 0, 0, 0, 0, 0
40034 : };
40035 : static PyGetSetDef this_getset_def = {
40036 : (char *)"this", &SwigPyBuiltin_ThisClosure, NULL, NULL, NULL
40037 : };
40038 : static SwigPyGetSet thisown_getset_closure = {
40039 : (PyCFunction) SwigPyObject_own,
40040 : (PyCFunction) SwigPyObject_own
40041 : };
40042 : static PyGetSetDef thisown_getset_def = {
40043 : (char *)"thisown", SwigPyBuiltin_GetterClosure, SwigPyBuiltin_SetterClosure, NULL, &thisown_getset_closure
40044 : };
40045 : PyObject *metatype_args;
40046 : PyTypeObject *builtin_pytype;
40047 : int builtin_base_count;
40048 : swig_type_info *builtin_basetype;
40049 : PyObject *tuple;
40050 : PyGetSetDescrObject *static_getset;
40051 : PyTypeObject *metatype;
40052 : SwigPyClientData *cd;
40053 : PyObject *public_interface, *public_symbol;
40054 : PyObject *this_descr;
40055 : PyObject *thisown_descr;
40056 : PyObject *self = 0;
40057 : int i;
40058 :
40059 : (void)builtin_pytype;
40060 : (void)builtin_base_count;
40061 : (void)builtin_basetype;
40062 : (void)tuple;
40063 : (void)static_getset;
40064 : (void)self;
40065 :
40066 : /* metatype is used to implement static member variables. */
40067 : metatype_args = Py_BuildValue("(s(O){})", "SwigPyObjectType", &PyType_Type);
40068 : assert(metatype_args);
40069 : metatype = (PyTypeObject *) PyType_Type.tp_call((PyObject *) &PyType_Type, metatype_args, NULL);
40070 : assert(metatype);
40071 : Py_DECREF(metatype_args);
40072 : metatype->tp_setattro = (setattrofunc) &SwigPyObjectType_setattro;
40073 : assert(PyType_Ready(metatype) >= 0);
40074 : #endif
40075 :
40076 : /* Fix SwigMethods to carry the callback ptrs when needed */
40077 27 : SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
40078 :
40079 : #if PY_VERSION_HEX >= 0x03000000
40080 : m = PyModule_Create(&SWIG_module);
40081 : #else
40082 27 : m = Py_InitModule((char *) SWIG_name, SwigMethods);
40083 : #endif
40084 :
40085 27 : md = d = PyModule_GetDict(m);
40086 : (void)md;
40087 :
40088 27 : SWIG_InitializeModule(0);
40089 :
40090 : #ifdef SWIGPYTHON_BUILTIN
40091 : SwigPyObject_stype = SWIG_MangledTypeQuery("_p_SwigPyObject");
40092 : assert(SwigPyObject_stype);
40093 : cd = (SwigPyClientData*) SwigPyObject_stype->clientdata;
40094 : if (!cd) {
40095 : SwigPyObject_stype->clientdata = &SwigPyObject_clientdata;
40096 : SwigPyObject_clientdata.pytype = SwigPyObject_TypeOnce();
40097 : } else if (SwigPyObject_TypeOnce()->tp_basicsize != cd->pytype->tp_basicsize) {
40098 : PyErr_SetString(PyExc_RuntimeError, "Import error: attempted to load two incompatible swig-generated modules.");
40099 : # if PY_VERSION_HEX >= 0x03000000
40100 : return NULL;
40101 : # else
40102 : return;
40103 : # endif
40104 : }
40105 :
40106 : /* All objects have a 'this' attribute */
40107 : this_descr = PyDescr_NewGetSet(SwigPyObject_type(), &this_getset_def);
40108 : (void)this_descr;
40109 :
40110 : /* All objects have a 'thisown' attribute */
40111 : thisown_descr = PyDescr_NewGetSet(SwigPyObject_type(), &thisown_getset_def);
40112 : (void)thisown_descr;
40113 :
40114 : public_interface = PyList_New(0);
40115 : public_symbol = 0;
40116 : (void)public_symbol;
40117 :
40118 : PyDict_SetItemString(md, "__all__", public_interface);
40119 : Py_DECREF(public_interface);
40120 : for (i = 0; SwigMethods[i].ml_name != NULL; ++i)
40121 : SwigPyBuiltin_AddPublicSymbol(public_interface, SwigMethods[i].ml_name);
40122 : for (i = 0; swig_const_table[i].name != 0; ++i)
40123 : SwigPyBuiltin_AddPublicSymbol(public_interface, swig_const_table[i].name);
40124 : #endif
40125 :
40126 27 : SWIG_InstallConstants(d,swig_const_table);
40127 :
40128 27 : SWIG_Python_SetConstant(d, "BUILD_REVISION",SWIG_FromCharPtr("4139877"));
40129 27 : SWIG_Python_SetConstant(d, "BUILD_TIMESTAMP",SWIG_FromCharPtr("<none>"));
40130 27 : SWIG_Python_SetConstant(d, "ENABLE_UISERVER",SWIG_From_int((int)(1)));
40131 27 : SWIG_Python_SetConstant(d, "GPGME_LIBASSUAN_VERSION",SWIG_FromCharPtr(""));
40132 27 : SWIG_Python_SetConstant(d, "HAVE_ARGP_H",SWIG_From_int((int)(1)));
40133 27 : SWIG_Python_SetConstant(d, "HAVE_CXX11",SWIG_From_int((int)(1)));
40134 27 : SWIG_Python_SetConstant(d, "HAVE_DECL_TTYNAME_R",SWIG_From_int((int)(1)));
40135 27 : SWIG_Python_SetConstant(d, "HAVE_DLFCN_H",SWIG_From_int((int)(1)));
40136 27 : SWIG_Python_SetConstant(d, "HAVE_ERROR_T",SWIG_From_int((int)(1)));
40137 27 : SWIG_Python_SetConstant(d, "HAVE_FSEEKO",SWIG_From_int((int)(1)));
40138 27 : SWIG_Python_SetConstant(d, "HAVE_GETEGID",SWIG_From_int((int)(1)));
40139 27 : SWIG_Python_SetConstant(d, "HAVE_GETGID",SWIG_From_int((int)(1)));
40140 27 : SWIG_Python_SetConstant(d, "HAVE_INTTYPES_H",SWIG_From_int((int)(1)));
40141 27 : SWIG_Python_SetConstant(d, "HAVE_LOCALE_H",SWIG_From_int((int)(1)));
40142 27 : SWIG_Python_SetConstant(d, "HAVE_MEMORY_H",SWIG_From_int((int)(1)));
40143 27 : SWIG_Python_SetConstant(d, "HAVE_POSIXDECL_TTYNAME_R",SWIG_From_int((int)(1)));
40144 27 : SWIG_Python_SetConstant(d, "HAVE_PYTHON",SWIG_FromCharPtr("3.5"));
40145 27 : SWIG_Python_SetConstant(d, "HAVE_SETENV",SWIG_From_int((int)(1)));
40146 27 : SWIG_Python_SetConstant(d, "HAVE_SETLOCALE",SWIG_From_int((int)(1)));
40147 27 : SWIG_Python_SetConstant(d, "HAVE_STDINT_H",SWIG_From_int((int)(1)));
40148 27 : SWIG_Python_SetConstant(d, "HAVE_STDLIB_H",SWIG_From_int((int)(1)));
40149 27 : SWIG_Python_SetConstant(d, "HAVE_STPCPY",SWIG_From_int((int)(1)));
40150 27 : SWIG_Python_SetConstant(d, "HAVE_STRINGS_H",SWIG_From_int((int)(1)));
40151 27 : SWIG_Python_SetConstant(d, "HAVE_STRING_H",SWIG_From_int((int)(1)));
40152 27 : SWIG_Python_SetConstant(d, "HAVE_SYS_SELECT_H",SWIG_From_int((int)(1)));
40153 27 : SWIG_Python_SetConstant(d, "HAVE_SYS_STAT_H",SWIG_From_int((int)(1)));
40154 27 : SWIG_Python_SetConstant(d, "HAVE_SYS_TIME_H",SWIG_From_int((int)(1)));
40155 27 : SWIG_Python_SetConstant(d, "HAVE_SYS_TYPES_H",SWIG_From_int((int)(1)));
40156 27 : SWIG_Python_SetConstant(d, "HAVE_SYS_UIO_H",SWIG_From_int((int)(1)));
40157 27 : SWIG_Python_SetConstant(d, "HAVE_THREAD_SAFE_GETENV",SWIG_From_int((int)(1)));
40158 27 : SWIG_Python_SetConstant(d, "HAVE_TIMEGM",SWIG_From_int((int)(1)));
40159 27 : SWIG_Python_SetConstant(d, "HAVE_TLS",SWIG_From_int((int)(1)));
40160 27 : SWIG_Python_SetConstant(d, "HAVE_TTYNAME_R",SWIG_From_int((int)(1)));
40161 27 : SWIG_Python_SetConstant(d, "HAVE_UINTPTR_T",SWIG_From_int((int)(1)));
40162 27 : SWIG_Python_SetConstant(d, "HAVE_UNISTD_H",SWIG_From_int((int)(1)));
40163 27 : SWIG_Python_SetConstant(d, "LT_OBJDIR",SWIG_FromCharPtr(".libs/"));
40164 27 : SWIG_Python_SetConstant(d, "PACKAGE",SWIG_FromCharPtr("gpgme"));
40165 27 : SWIG_Python_SetConstant(d, "PACKAGE_BUGREPORT",SWIG_FromCharPtr("http://bugs.gnupg.org"));
40166 27 : SWIG_Python_SetConstant(d, "PACKAGE_NAME",SWIG_FromCharPtr("gpgme"));
40167 27 : SWIG_Python_SetConstant(d, "PACKAGE_STRING",SWIG_FromCharPtr("gpgme 1.8.1"));
40168 27 : SWIG_Python_SetConstant(d, "PACKAGE_TARNAME",SWIG_FromCharPtr("gpgme"));
40169 27 : SWIG_Python_SetConstant(d, "PACKAGE_URL",SWIG_FromCharPtr(""));
40170 27 : SWIG_Python_SetConstant(d, "PACKAGE_VERSION",SWIG_FromCharPtr("1.8.1"));
40171 27 : SWIG_Python_SetConstant(d, "PATHSEP_C",SWIG_From_char((char)(':')));
40172 27 : SWIG_Python_SetConstant(d, "DIRSEP_C",SWIG_From_char((char)('/')));
40173 27 : SWIG_Python_SetConstant(d, "DIRSEP_S",SWIG_FromCharPtr("/"));
40174 27 : SWIG_Python_SetConstant(d, "SIZEOF_UNSIGNED_INT",SWIG_From_int((int)(4)));
40175 27 : SWIG_Python_SetConstant(d, "STDC_HEADERS",SWIG_From_int((int)(1)));
40176 27 : SWIG_Python_SetConstant(d, "USE_DESCRIPTOR_PASSING",SWIG_From_int((int)(1)));
40177 27 : SWIG_Python_SetConstant(d, "_ALL_SOURCE",SWIG_From_int((int)(1)));
40178 27 : SWIG_Python_SetConstant(d, "_GNU_SOURCE",SWIG_From_int((int)(1)));
40179 27 : SWIG_Python_SetConstant(d, "_POSIX_PTHREAD_SEMANTICS",SWIG_From_int((int)(1)));
40180 27 : SWIG_Python_SetConstant(d, "_TANDEM_SOURCE",SWIG_From_int((int)(1)));
40181 27 : SWIG_Python_SetConstant(d, "__EXTENSIONS__",SWIG_From_int((int)(1)));
40182 27 : SWIG_Python_SetConstant(d, "VERSION",SWIG_FromCharPtr("1.8.1"));
40183 27 : SWIG_Python_SetConstant(d, "_DARWIN_USE_64_BIT_INODE",SWIG_From_int((int)(1)));
40184 27 : SWIG_Python_SetConstant(d, "_REENTRANT",SWIG_From_int((int)(1)));
40185 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENABLE_ERRNO_MACROS",SWIG_From_int((int)(1)));
40186 27 : SWIG_Python_SetConstant(d, "CRIGHTBLURB",SWIG_FromCharPtr("Copyright (C) 2000 Werner Koch\nCopyright (C) 2001--2016 g10 Code GmbH\n"));
40187 27 : SWIG_Python_SetConstant(d, "GPGME_VERSION",SWIG_FromCharPtr("1.8.1"));
40188 27 : SWIG_Python_SetConstant(d, "GPGME_VERSION_NUMBER",SWIG_From_int((int)(0x010801)));
40189 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_NONE",SWIG_From_int((int)(GPGME_DATA_ENCODING_NONE)));
40190 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_BINARY",SWIG_From_int((int)(GPGME_DATA_ENCODING_BINARY)));
40191 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_BASE64",SWIG_From_int((int)(GPGME_DATA_ENCODING_BASE64)));
40192 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_ARMOR",SWIG_From_int((int)(GPGME_DATA_ENCODING_ARMOR)));
40193 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URL",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL)));
40194 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URLESC",SWIG_From_int((int)(GPGME_DATA_ENCODING_URLESC)));
40195 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_URL0",SWIG_From_int((int)(GPGME_DATA_ENCODING_URL0)));
40196 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_ENCODING_MIME",SWIG_From_int((int)(GPGME_DATA_ENCODING_MIME)));
40197 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_INVALID",SWIG_From_int((int)(GPGME_DATA_TYPE_INVALID)));
40198 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_UNKNOWN",SWIG_From_int((int)(GPGME_DATA_TYPE_UNKNOWN)));
40199 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNED)));
40200 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_ENCRYPTED)));
40201 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_OTHER)));
40202 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_KEY",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_KEY)));
40203 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PGP_SIGNATURE",SWIG_From_int((int)(GPGME_DATA_TYPE_PGP_SIGNATURE)));
40204 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_SIGNED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_SIGNED)));
40205 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_ENCRYPTED",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_ENCRYPTED)));
40206 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_CMS_OTHER",SWIG_From_int((int)(GPGME_DATA_TYPE_CMS_OTHER)));
40207 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_X509_CERT",SWIG_From_int((int)(GPGME_DATA_TYPE_X509_CERT)));
40208 27 : SWIG_Python_SetConstant(d, "GPGME_DATA_TYPE_PKCS12",SWIG_From_int((int)(GPGME_DATA_TYPE_PKCS12)));
40209 27 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA",SWIG_From_int((int)(GPGME_PK_RSA)));
40210 27 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA_E",SWIG_From_int((int)(GPGME_PK_RSA_E)));
40211 27 : SWIG_Python_SetConstant(d, "GPGME_PK_RSA_S",SWIG_From_int((int)(GPGME_PK_RSA_S)));
40212 27 : SWIG_Python_SetConstant(d, "GPGME_PK_ELG_E",SWIG_From_int((int)(GPGME_PK_ELG_E)));
40213 27 : SWIG_Python_SetConstant(d, "GPGME_PK_DSA",SWIG_From_int((int)(GPGME_PK_DSA)));
40214 27 : SWIG_Python_SetConstant(d, "GPGME_PK_ECC",SWIG_From_int((int)(GPGME_PK_ECC)));
40215 27 : SWIG_Python_SetConstant(d, "GPGME_PK_ELG",SWIG_From_int((int)(GPGME_PK_ELG)));
40216 27 : SWIG_Python_SetConstant(d, "GPGME_PK_ECDSA",SWIG_From_int((int)(GPGME_PK_ECDSA)));
40217 27 : SWIG_Python_SetConstant(d, "GPGME_PK_ECDH",SWIG_From_int((int)(GPGME_PK_ECDH)));
40218 27 : SWIG_Python_SetConstant(d, "GPGME_PK_EDDSA",SWIG_From_int((int)(GPGME_PK_EDDSA)));
40219 27 : SWIG_Python_SetConstant(d, "GPGME_MD_NONE",SWIG_From_int((int)(GPGME_MD_NONE)));
40220 27 : SWIG_Python_SetConstant(d, "GPGME_MD_MD5",SWIG_From_int((int)(GPGME_MD_MD5)));
40221 27 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA1",SWIG_From_int((int)(GPGME_MD_SHA1)));
40222 27 : SWIG_Python_SetConstant(d, "GPGME_MD_RMD160",SWIG_From_int((int)(GPGME_MD_RMD160)));
40223 27 : SWIG_Python_SetConstant(d, "GPGME_MD_MD2",SWIG_From_int((int)(GPGME_MD_MD2)));
40224 27 : SWIG_Python_SetConstant(d, "GPGME_MD_TIGER",SWIG_From_int((int)(GPGME_MD_TIGER)));
40225 27 : SWIG_Python_SetConstant(d, "GPGME_MD_HAVAL",SWIG_From_int((int)(GPGME_MD_HAVAL)));
40226 27 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA256",SWIG_From_int((int)(GPGME_MD_SHA256)));
40227 27 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA384",SWIG_From_int((int)(GPGME_MD_SHA384)));
40228 27 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA512",SWIG_From_int((int)(GPGME_MD_SHA512)));
40229 27 : SWIG_Python_SetConstant(d, "GPGME_MD_SHA224",SWIG_From_int((int)(GPGME_MD_SHA224)));
40230 27 : SWIG_Python_SetConstant(d, "GPGME_MD_MD4",SWIG_From_int((int)(GPGME_MD_MD4)));
40231 27 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC32",SWIG_From_int((int)(GPGME_MD_CRC32)));
40232 27 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC32_RFC1510",SWIG_From_int((int)(GPGME_MD_CRC32_RFC1510)));
40233 27 : SWIG_Python_SetConstant(d, "GPGME_MD_CRC24_RFC2440",SWIG_From_int((int)(GPGME_MD_CRC24_RFC2440)));
40234 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_NORMAL",SWIG_From_int((int)(GPGME_SIG_MODE_NORMAL)));
40235 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_DETACH",SWIG_From_int((int)(GPGME_SIG_MODE_DETACH)));
40236 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_MODE_CLEAR",SWIG_From_int((int)(GPGME_SIG_MODE_CLEAR)));
40237 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_UNKNOWN",SWIG_From_int((int)(GPGME_VALIDITY_UNKNOWN)));
40238 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_UNDEFINED",SWIG_From_int((int)(GPGME_VALIDITY_UNDEFINED)));
40239 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_NEVER",SWIG_From_int((int)(GPGME_VALIDITY_NEVER)));
40240 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_MARGINAL",SWIG_From_int((int)(GPGME_VALIDITY_MARGINAL)));
40241 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_FULL",SWIG_From_int((int)(GPGME_VALIDITY_FULL)));
40242 27 : SWIG_Python_SetConstant(d, "GPGME_VALIDITY_ULTIMATE",SWIG_From_int((int)(GPGME_VALIDITY_ULTIMATE)));
40243 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_NONE",SWIG_From_int((int)(GPGME_TOFU_POLICY_NONE)));
40244 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_AUTO",SWIG_From_int((int)(GPGME_TOFU_POLICY_AUTO)));
40245 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_GOOD",SWIG_From_int((int)(GPGME_TOFU_POLICY_GOOD)));
40246 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_UNKNOWN",SWIG_From_int((int)(GPGME_TOFU_POLICY_UNKNOWN)));
40247 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_BAD",SWIG_From_int((int)(GPGME_TOFU_POLICY_BAD)));
40248 27 : SWIG_Python_SetConstant(d, "GPGME_TOFU_POLICY_ASK",SWIG_From_int((int)(GPGME_TOFU_POLICY_ASK)));
40249 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_OpenPGP",SWIG_From_int((int)(GPGME_PROTOCOL_OpenPGP)));
40250 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_CMS",SWIG_From_int((int)(GPGME_PROTOCOL_CMS)));
40251 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_GPGCONF",SWIG_From_int((int)(GPGME_PROTOCOL_GPGCONF)));
40252 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_ASSUAN",SWIG_From_int((int)(GPGME_PROTOCOL_ASSUAN)));
40253 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_G13",SWIG_From_int((int)(GPGME_PROTOCOL_G13)));
40254 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_UISERVER",SWIG_From_int((int)(GPGME_PROTOCOL_UISERVER)));
40255 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_SPAWN",SWIG_From_int((int)(GPGME_PROTOCOL_SPAWN)));
40256 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_DEFAULT",SWIG_From_int((int)(GPGME_PROTOCOL_DEFAULT)));
40257 27 : SWIG_Python_SetConstant(d, "GPGME_PROTOCOL_UNKNOWN",SWIG_From_int((int)(GPGME_PROTOCOL_UNKNOWN)));
40258 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_LOCAL",SWIG_From_int((int)(1)));
40259 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_EXTERN",SWIG_From_int((int)(2)));
40260 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_SIGS",SWIG_From_int((int)(4)));
40261 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_SIG_NOTATIONS",SWIG_From_int((int)(8)));
40262 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_WITH_SECRET",SWIG_From_int((int)(16)));
40263 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_WITH_TOFU",SWIG_From_int((int)(32)));
40264 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_EPHEMERAL",SWIG_From_int((int)(128)));
40265 27 : SWIG_Python_SetConstant(d, "GPGME_KEYLIST_MODE_VALIDATE",SWIG_From_int((int)(256)));
40266 27 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_DEFAULT",SWIG_From_int((int)(GPGME_PINENTRY_MODE_DEFAULT)));
40267 27 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_ASK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ASK)));
40268 27 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_CANCEL",SWIG_From_int((int)(GPGME_PINENTRY_MODE_CANCEL)));
40269 27 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_ERROR",SWIG_From_int((int)(GPGME_PINENTRY_MODE_ERROR)));
40270 27 : SWIG_Python_SetConstant(d, "GPGME_PINENTRY_MODE_LOOPBACK",SWIG_From_int((int)(GPGME_PINENTRY_MODE_LOOPBACK)));
40271 27 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_EXTERN",SWIG_From_int((int)(2)));
40272 27 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_MINIMAL",SWIG_From_int((int)(4)));
40273 27 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_SECRET",SWIG_From_int((int)(16)));
40274 27 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_RAW",SWIG_From_int((int)(32)));
40275 27 : SWIG_Python_SetConstant(d, "GPGME_EXPORT_MODE_PKCS12",SWIG_From_int((int)(64)));
40276 27 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_HTML",SWIG_From_int((int)(1)));
40277 27 : SWIG_Python_SetConstant(d, "GPGME_AUDITLOG_WITH_HELP",SWIG_From_int((int)(128)));
40278 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_NOTATION_HUMAN_READABLE",SWIG_From_int((int)(1)));
40279 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_NOTATION_CRITICAL",SWIG_From_int((int)(2)));
40280 27 : SWIG_Python_SetConstant(d, "GPGME_INCLUDE_CERTS_DEFAULT",SWIG_From_int((int)(-256)));
40281 27 : SWIG_Python_SetConstant(d, "GPGME_EVENT_START",SWIG_From_int((int)(GPGME_EVENT_START)));
40282 27 : SWIG_Python_SetConstant(d, "GPGME_EVENT_DONE",SWIG_From_int((int)(GPGME_EVENT_DONE)));
40283 27 : SWIG_Python_SetConstant(d, "GPGME_EVENT_NEXT_KEY",SWIG_From_int((int)(GPGME_EVENT_NEXT_KEY)));
40284 27 : SWIG_Python_SetConstant(d, "GPGME_EVENT_NEXT_TRUSTITEM",SWIG_From_int((int)(GPGME_EVENT_NEXT_TRUSTITEM)));
40285 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_ALWAYS_TRUST",SWIG_From_int((int)(GPGME_ENCRYPT_ALWAYS_TRUST)));
40286 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_NO_ENCRYPT_TO",SWIG_From_int((int)(GPGME_ENCRYPT_NO_ENCRYPT_TO)));
40287 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_PREPARE",SWIG_From_int((int)(GPGME_ENCRYPT_PREPARE)));
40288 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_EXPECT_SIGN",SWIG_From_int((int)(GPGME_ENCRYPT_EXPECT_SIGN)));
40289 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_NO_COMPRESS",SWIG_From_int((int)(GPGME_ENCRYPT_NO_COMPRESS)));
40290 27 : SWIG_Python_SetConstant(d, "GPGME_ENCRYPT_SYMMETRIC",SWIG_From_int((int)(GPGME_ENCRYPT_SYMMETRIC)));
40291 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_VALID",SWIG_From_int((int)(GPGME_SIGSUM_VALID)));
40292 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_GREEN",SWIG_From_int((int)(GPGME_SIGSUM_GREEN)));
40293 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_RED",SWIG_From_int((int)(GPGME_SIGSUM_RED)));
40294 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_REVOKED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_REVOKED)));
40295 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_KEY_EXPIRED)));
40296 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_SIG_EXPIRED",SWIG_From_int((int)(GPGME_SIGSUM_SIG_EXPIRED)));
40297 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_KEY_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_KEY_MISSING)));
40298 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_CRL_MISSING",SWIG_From_int((int)(GPGME_SIGSUM_CRL_MISSING)));
40299 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_CRL_TOO_OLD",SWIG_From_int((int)(GPGME_SIGSUM_CRL_TOO_OLD)));
40300 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_BAD_POLICY",SWIG_From_int((int)(GPGME_SIGSUM_BAD_POLICY)));
40301 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_SYS_ERROR",SWIG_From_int((int)(GPGME_SIGSUM_SYS_ERROR)));
40302 27 : SWIG_Python_SetConstant(d, "GPGME_SIGSUM_TOFU_CONFLICT",SWIG_From_int((int)(GPGME_SIGSUM_TOFU_CONFLICT)));
40303 27 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_NEW",SWIG_From_int((int)(1)));
40304 27 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_UID",SWIG_From_int((int)(2)));
40305 27 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SIG",SWIG_From_int((int)(4)));
40306 27 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SUBKEY",SWIG_From_int((int)(8)));
40307 27 : SWIG_Python_SetConstant(d, "GPGME_IMPORT_SECRET",SWIG_From_int((int)(16)));
40308 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_SIGN",SWIG_From_int((int)((1 << 0))));
40309 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_ENCR",SWIG_From_int((int)((1 << 1))));
40310 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_CERT",SWIG_From_int((int)((1 << 2))));
40311 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_AUTH",SWIG_From_int((int)((1 << 3))));
40312 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOPASSWD",SWIG_From_int((int)((1 << 7))));
40313 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_SELFSIGNED",SWIG_From_int((int)((1 << 8))));
40314 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOSTORE",SWIG_From_int((int)((1 << 9))));
40315 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_WANTPUB",SWIG_From_int((int)((1 << 10))));
40316 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_WANTSEC",SWIG_From_int((int)((1 << 11))));
40317 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_FORCE",SWIG_From_int((int)((1 << 12))));
40318 27 : SWIG_Python_SetConstant(d, "GPGME_CREATE_NOEXPIRE",SWIG_From_int((int)((1 << 13))));
40319 27 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_LOCAL",SWIG_From_int((int)((1 << 7))));
40320 27 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_LFSEP",SWIG_From_int((int)((1 << 8))));
40321 27 : SWIG_Python_SetConstant(d, "GPGME_KEYSIGN_NOEXPIRE",SWIG_From_int((int)((1 << 9))));
40322 27 : SWIG_Python_SetConstant(d, "GPGME_INTERACT_CARD",SWIG_From_int((int)((1 << 0))));
40323 27 : SWIG_Python_SetConstant(d, "GPGME_SPAWN_DETACHED",SWIG_From_int((int)(1)));
40324 27 : SWIG_Python_SetConstant(d, "GPGME_SPAWN_ALLOW_SET_FG",SWIG_From_int((int)(2)));
40325 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_BASIC",SWIG_From_int((int)(GPGME_CONF_BASIC)));
40326 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_ADVANCED",SWIG_From_int((int)(GPGME_CONF_ADVANCED)));
40327 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_EXPERT",SWIG_From_int((int)(GPGME_CONF_EXPERT)));
40328 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_INVISIBLE",SWIG_From_int((int)(GPGME_CONF_INVISIBLE)));
40329 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_INTERNAL",SWIG_From_int((int)(GPGME_CONF_INTERNAL)));
40330 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_NONE",SWIG_From_int((int)(GPGME_CONF_NONE)));
40331 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_STRING",SWIG_From_int((int)(GPGME_CONF_STRING)));
40332 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_INT32",SWIG_From_int((int)(GPGME_CONF_INT32)));
40333 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_UINT32",SWIG_From_int((int)(GPGME_CONF_UINT32)));
40334 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_FILENAME",SWIG_From_int((int)(GPGME_CONF_FILENAME)));
40335 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_LDAP_SERVER",SWIG_From_int((int)(GPGME_CONF_LDAP_SERVER)));
40336 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_KEY_FPR",SWIG_From_int((int)(GPGME_CONF_KEY_FPR)));
40337 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_PUB_KEY",SWIG_From_int((int)(GPGME_CONF_PUB_KEY)));
40338 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_SEC_KEY",SWIG_From_int((int)(GPGME_CONF_SEC_KEY)));
40339 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_ALIAS_LIST",SWIG_From_int((int)(GPGME_CONF_ALIAS_LIST)));
40340 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_GROUP",SWIG_From_int((int)((1 << 0))));
40341 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_OPTIONAL",SWIG_From_int((int)((1 << 1))));
40342 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_LIST",SWIG_From_int((int)((1 << 2))));
40343 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_RUNTIME",SWIG_From_int((int)((1 << 3))));
40344 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_DEFAULT",SWIG_From_int((int)((1 << 4))));
40345 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_DEFAULT_DESC",SWIG_From_int((int)((1 << 5))));
40346 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_NO_ARG_DESC",SWIG_From_int((int)((1 << 6))));
40347 27 : SWIG_Python_SetConstant(d, "GPGME_CONF_NO_CHANGE",SWIG_From_int((int)((1 << 7))));
40348 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EOF",SWIG_From_int((int)(GPGME_STATUS_EOF)));
40349 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ENTER",SWIG_From_int((int)(GPGME_STATUS_ENTER)));
40350 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_LEAVE",SWIG_From_int((int)(GPGME_STATUS_LEAVE)));
40351 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ABORT",SWIG_From_int((int)(GPGME_STATUS_ABORT)));
40352 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOODSIG",SWIG_From_int((int)(GPGME_STATUS_GOODSIG)));
40353 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADSIG",SWIG_From_int((int)(GPGME_STATUS_BADSIG)));
40354 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERRSIG",SWIG_From_int((int)(GPGME_STATUS_ERRSIG)));
40355 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADARMOR",SWIG_From_int((int)(GPGME_STATUS_BADARMOR)));
40356 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_RSA_OR_IDEA",SWIG_From_int((int)(GPGME_STATUS_RSA_OR_IDEA)));
40357 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEYEXPIRED",SWIG_From_int((int)(GPGME_STATUS_KEYEXPIRED)));
40358 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEYREVOKED",SWIG_From_int((int)(GPGME_STATUS_KEYREVOKED)));
40359 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_UNDEFINED",SWIG_From_int((int)(GPGME_STATUS_TRUST_UNDEFINED)));
40360 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_NEVER",SWIG_From_int((int)(GPGME_STATUS_TRUST_NEVER)));
40361 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_MARGINAL",SWIG_From_int((int)(GPGME_STATUS_TRUST_MARGINAL)));
40362 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_FULLY",SWIG_From_int((int)(GPGME_STATUS_TRUST_FULLY)));
40363 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUST_ULTIMATE",SWIG_From_int((int)(GPGME_STATUS_TRUST_ULTIMATE)));
40364 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_INFO",SWIG_From_int((int)(GPGME_STATUS_SHM_INFO)));
40365 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET",SWIG_From_int((int)(GPGME_STATUS_SHM_GET)));
40366 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_BOOL)));
40367 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SHM_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_SHM_GET_HIDDEN)));
40368 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE)));
40369 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_VALIDSIG",SWIG_From_int((int)(GPGME_STATUS_VALIDSIG)));
40370 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_ID",SWIG_From_int((int)(GPGME_STATUS_SIG_ID)));
40371 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ENC_TO",SWIG_From_int((int)(GPGME_STATUS_ENC_TO)));
40372 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NODATA",SWIG_From_int((int)(GPGME_STATUS_NODATA)));
40373 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BAD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_BAD_PASSPHRASE)));
40374 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_PUBKEY",SWIG_From_int((int)(GPGME_STATUS_NO_PUBKEY)));
40375 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_SECKEY",SWIG_From_int((int)(GPGME_STATUS_NO_SECKEY)));
40376 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE_SYM",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_SYM)));
40377 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_FAILED",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_FAILED)));
40378 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_OKAY",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_OKAY)));
40379 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_MISSING_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_MISSING_PASSPHRASE)));
40380 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOOD_PASSPHRASE",SWIG_From_int((int)(GPGME_STATUS_GOOD_PASSPHRASE)));
40381 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOODMDC",SWIG_From_int((int)(GPGME_STATUS_GOODMDC)));
40382 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BADMDC",SWIG_From_int((int)(GPGME_STATUS_BADMDC)));
40383 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERRMDC",SWIG_From_int((int)(GPGME_STATUS_ERRMDC)));
40384 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORTED",SWIG_From_int((int)(GPGME_STATUS_IMPORTED)));
40385 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_OK",SWIG_From_int((int)(GPGME_STATUS_IMPORT_OK)));
40386 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_IMPORT_PROBLEM)));
40387 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_IMPORT_RES",SWIG_From_int((int)(GPGME_STATUS_IMPORT_RES)));
40388 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_START",SWIG_From_int((int)(GPGME_STATUS_FILE_START)));
40389 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_DONE",SWIG_From_int((int)(GPGME_STATUS_FILE_DONE)));
40390 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FILE_ERROR",SWIG_From_int((int)(GPGME_STATUS_FILE_ERROR)));
40391 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_DECRYPTION)));
40392 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_DECRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_DECRYPTION)));
40393 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_BEGIN_ENCRYPTION)));
40394 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_ENCRYPTION",SWIG_From_int((int)(GPGME_STATUS_END_ENCRYPTION)));
40395 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DELETE_PROBLEM",SWIG_From_int((int)(GPGME_STATUS_DELETE_PROBLEM)));
40396 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_BOOL",SWIG_From_int((int)(GPGME_STATUS_GET_BOOL)));
40397 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_LINE",SWIG_From_int((int)(GPGME_STATUS_GET_LINE)));
40398 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GET_HIDDEN",SWIG_From_int((int)(GPGME_STATUS_GET_HIDDEN)));
40399 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_GOT_IT",SWIG_From_int((int)(GPGME_STATUS_GOT_IT)));
40400 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PROGRESS",SWIG_From_int((int)(GPGME_STATUS_PROGRESS)));
40401 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_CREATED",SWIG_From_int((int)(GPGME_STATUS_SIG_CREATED)));
40402 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SESSION_KEY",SWIG_From_int((int)(GPGME_STATUS_SESSION_KEY)));
40403 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_NAME",SWIG_From_int((int)(GPGME_STATUS_NOTATION_NAME)));
40404 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_DATA",SWIG_From_int((int)(GPGME_STATUS_NOTATION_DATA)));
40405 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_POLICY_URL",SWIG_From_int((int)(GPGME_STATUS_POLICY_URL)));
40406 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_STREAM",SWIG_From_int((int)(GPGME_STATUS_BEGIN_STREAM)));
40407 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_END_STREAM",SWIG_From_int((int)(GPGME_STATUS_END_STREAM)));
40408 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_CREATED)));
40409 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_USERID_HINT",SWIG_From_int((int)(GPGME_STATUS_USERID_HINT)));
40410 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_UNEXPECTED",SWIG_From_int((int)(GPGME_STATUS_UNEXPECTED)));
40411 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INV_RECP",SWIG_From_int((int)(GPGME_STATUS_INV_RECP)));
40412 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_RECP",SWIG_From_int((int)(GPGME_STATUS_NO_RECP)));
40413 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ALREADY_SIGNED",SWIG_From_int((int)(GPGME_STATUS_ALREADY_SIGNED)));
40414 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIGEXPIRED",SWIG_From_int((int)(GPGME_STATUS_SIGEXPIRED)));
40415 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EXPSIG",SWIG_From_int((int)(GPGME_STATUS_EXPSIG)));
40416 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_EXPKEYSIG",SWIG_From_int((int)(GPGME_STATUS_EXPKEYSIG)));
40417 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TRUNCATED",SWIG_From_int((int)(GPGME_STATUS_TRUNCATED)));
40418 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ERROR",SWIG_From_int((int)(GPGME_STATUS_ERROR)));
40419 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEWSIG",SWIG_From_int((int)(GPGME_STATUS_NEWSIG)));
40420 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_REVKEYSIG",SWIG_From_int((int)(GPGME_STATUS_REVKEYSIG)));
40421 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SIG_SUBPACKET",SWIG_From_int((int)(GPGME_STATUS_SIG_SUBPACKET)));
40422 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NEED_PASSPHRASE_PIN",SWIG_From_int((int)(GPGME_STATUS_NEED_PASSPHRASE_PIN)));
40423 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SC_OP_FAILURE",SWIG_From_int((int)(GPGME_STATUS_SC_OP_FAILURE)));
40424 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SC_OP_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SC_OP_SUCCESS)));
40425 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_CARDCTRL",SWIG_From_int((int)(GPGME_STATUS_CARDCTRL)));
40426 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BACKUP_KEY_CREATED",SWIG_From_int((int)(GPGME_STATUS_BACKUP_KEY_CREATED)));
40427 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PKA_TRUST_BAD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_BAD)));
40428 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PKA_TRUST_GOOD",SWIG_From_int((int)(GPGME_STATUS_PKA_TRUST_GOOD)));
40429 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PLAINTEXT",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT)));
40430 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INV_SGNR",SWIG_From_int((int)(GPGME_STATUS_INV_SGNR)));
40431 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NO_SGNR",SWIG_From_int((int)(GPGME_STATUS_NO_SGNR)));
40432 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_SUCCESS",SWIG_From_int((int)(GPGME_STATUS_SUCCESS)));
40433 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_DECRYPTION_INFO",SWIG_From_int((int)(GPGME_STATUS_DECRYPTION_INFO)));
40434 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PLAINTEXT_LENGTH",SWIG_From_int((int)(GPGME_STATUS_PLAINTEXT_LENGTH)));
40435 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_MOUNTPOINT",SWIG_From_int((int)(GPGME_STATUS_MOUNTPOINT)));
40436 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_PINENTRY_LAUNCHED",SWIG_From_int((int)(GPGME_STATUS_PINENTRY_LAUNCHED)));
40437 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_ATTRIBUTE",SWIG_From_int((int)(GPGME_STATUS_ATTRIBUTE)));
40438 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_BEGIN_SIGNING",SWIG_From_int((int)(GPGME_STATUS_BEGIN_SIGNING)));
40439 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_NOT_CREATED",SWIG_From_int((int)(GPGME_STATUS_KEY_NOT_CREATED)));
40440 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_INQUIRE_MAXLEN",SWIG_From_int((int)(GPGME_STATUS_INQUIRE_MAXLEN)));
40441 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_FAILURE",SWIG_From_int((int)(GPGME_STATUS_FAILURE)));
40442 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_KEY_CONSIDERED",SWIG_From_int((int)(GPGME_STATUS_KEY_CONSIDERED)));
40443 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_USER",SWIG_From_int((int)(GPGME_STATUS_TOFU_USER)));
40444 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_STATS",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS)));
40445 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_TOFU_STATS_LONG",SWIG_From_int((int)(GPGME_STATUS_TOFU_STATS_LONG)));
40446 27 : SWIG_Python_SetConstant(d, "GPGME_STATUS_NOTATION_FLAGS",SWIG_From_int((int)(GPGME_STATUS_NOTATION_FLAGS)));
40447 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NONE",SWIG_From_int((int)(GPGME_SIG_STAT_NONE)));
40448 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD)));
40449 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_BAD",SWIG_From_int((int)(GPGME_SIG_STAT_BAD)));
40450 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NOKEY",SWIG_From_int((int)(GPGME_SIG_STAT_NOKEY)));
40451 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_NOSIG",SWIG_From_int((int)(GPGME_SIG_STAT_NOSIG)));
40452 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_ERROR",SWIG_From_int((int)(GPGME_SIG_STAT_ERROR)));
40453 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_DIFF",SWIG_From_int((int)(GPGME_SIG_STAT_DIFF)));
40454 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD_EXP",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXP)));
40455 27 : SWIG_Python_SetConstant(d, "GPGME_SIG_STAT_GOOD_EXPKEY",SWIG_From_int((int)(GPGME_SIG_STAT_GOOD_EXPKEY)));
40456 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEYID",SWIG_From_int((int)(GPGME_ATTR_KEYID)));
40457 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_FPR",SWIG_From_int((int)(GPGME_ATTR_FPR)));
40458 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ALGO",SWIG_From_int((int)(GPGME_ATTR_ALGO)));
40459 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_LEN",SWIG_From_int((int)(GPGME_ATTR_LEN)));
40460 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CREATED",SWIG_From_int((int)(GPGME_ATTR_CREATED)));
40461 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_EXPIRE",SWIG_From_int((int)(GPGME_ATTR_EXPIRE)));
40462 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_OTRUST",SWIG_From_int((int)(GPGME_ATTR_OTRUST)));
40463 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_USERID",SWIG_From_int((int)(GPGME_ATTR_USERID)));
40464 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_NAME",SWIG_From_int((int)(GPGME_ATTR_NAME)));
40465 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_EMAIL",SWIG_From_int((int)(GPGME_ATTR_EMAIL)));
40466 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_COMMENT",SWIG_From_int((int)(GPGME_ATTR_COMMENT)));
40467 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_VALIDITY",SWIG_From_int((int)(GPGME_ATTR_VALIDITY)));
40468 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_LEVEL",SWIG_From_int((int)(GPGME_ATTR_LEVEL)));
40469 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_TYPE",SWIG_From_int((int)(GPGME_ATTR_TYPE)));
40470 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_IS_SECRET",SWIG_From_int((int)(GPGME_ATTR_IS_SECRET)));
40471 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_REVOKED",SWIG_From_int((int)(GPGME_ATTR_KEY_REVOKED)));
40472 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_INVALID",SWIG_From_int((int)(GPGME_ATTR_KEY_INVALID)));
40473 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_UID_REVOKED",SWIG_From_int((int)(GPGME_ATTR_UID_REVOKED)));
40474 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_UID_INVALID",SWIG_From_int((int)(GPGME_ATTR_UID_INVALID)));
40475 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_CAPS",SWIG_From_int((int)(GPGME_ATTR_KEY_CAPS)));
40476 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_ENCRYPT",SWIG_From_int((int)(GPGME_ATTR_CAN_ENCRYPT)));
40477 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_SIGN",SWIG_From_int((int)(GPGME_ATTR_CAN_SIGN)));
40478 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CAN_CERTIFY",SWIG_From_int((int)(GPGME_ATTR_CAN_CERTIFY)));
40479 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_EXPIRED",SWIG_From_int((int)(GPGME_ATTR_KEY_EXPIRED)));
40480 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_KEY_DISABLED",SWIG_From_int((int)(GPGME_ATTR_KEY_DISABLED)));
40481 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SERIAL",SWIG_From_int((int)(GPGME_ATTR_SERIAL)));
40482 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ISSUER",SWIG_From_int((int)(GPGME_ATTR_ISSUER)));
40483 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_CHAINID",SWIG_From_int((int)(GPGME_ATTR_CHAINID)));
40484 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_STATUS",SWIG_From_int((int)(GPGME_ATTR_SIG_STATUS)));
40485 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_ERRTOK",SWIG_From_int((int)(GPGME_ATTR_ERRTOK)));
40486 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_SUMMARY",SWIG_From_int((int)(GPGME_ATTR_SIG_SUMMARY)));
40487 27 : SWIG_Python_SetConstant(d, "GPGME_ATTR_SIG_CLASS",SWIG_From_int((int)(GPGME_ATTR_SIG_CLASS)));
40488 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_UNKNOWN",SWIG_From_long((long)(GPG_ERR_SOURCE_UNKNOWN)));
40489 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GCRYPT",SWIG_From_long((long)(GPG_ERR_SOURCE_GCRYPT)));
40490 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPG",SWIG_From_long((long)(GPG_ERR_SOURCE_GPG)));
40491 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGSM",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGSM)));
40492 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGAGENT",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGAGENT)));
40493 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_PINENTRY",SWIG_From_long((long)(GPG_ERR_SOURCE_PINENTRY)));
40494 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_SCD",SWIG_From_long((long)(GPG_ERR_SOURCE_SCD)));
40495 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPGME",SWIG_From_long((long)(GPG_ERR_SOURCE_GPGME)));
40496 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KEYBOX",SWIG_From_long((long)(GPG_ERR_SOURCE_KEYBOX)));
40497 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KSBA",SWIG_From_long((long)(GPG_ERR_SOURCE_KSBA)));
40498 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_DIRMNGR",SWIG_From_long((long)(GPG_ERR_SOURCE_DIRMNGR)));
40499 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GSTI",SWIG_From_long((long)(GPG_ERR_SOURCE_GSTI)));
40500 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_GPA",SWIG_From_long((long)(GPG_ERR_SOURCE_GPA)));
40501 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_KLEO",SWIG_From_long((long)(GPG_ERR_SOURCE_KLEO)));
40502 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_G13",SWIG_From_long((long)(GPG_ERR_SOURCE_G13)));
40503 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_ASSUAN",SWIG_From_long((long)(GPG_ERR_SOURCE_ASSUAN)));
40504 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_TLS",SWIG_From_long((long)(GPG_ERR_SOURCE_TLS)));
40505 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_ANY",SWIG_From_long((long)(GPG_ERR_SOURCE_ANY)));
40506 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_1",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_1)));
40507 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_2",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_2)));
40508 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_3",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_3)));
40509 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_USER_4",SWIG_From_long((long)(GPG_ERR_SOURCE_USER_4)));
40510 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SOURCE_DIM",SWIG_From_long((long)(GPG_ERR_SOURCE_DIM)));
40511 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ERROR",SWIG_From_long((long)(GPG_ERR_NO_ERROR)));
40512 27 : SWIG_Python_SetConstant(d, "GPG_ERR_GENERAL",SWIG_From_long((long)(GPG_ERR_GENERAL)));
40513 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_PACKET",SWIG_From_long((long)(GPG_ERR_UNKNOWN_PACKET)));
40514 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_VERSION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_VERSION)));
40515 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_PUBKEY_ALGO)));
40516 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DIGEST_ALGO",SWIG_From_long((long)(GPG_ERR_DIGEST_ALGO)));
40517 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PUBKEY",SWIG_From_long((long)(GPG_ERR_BAD_PUBKEY)));
40518 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_SECKEY",SWIG_From_long((long)(GPG_ERR_BAD_SECKEY)));
40519 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_SIGNATURE",SWIG_From_long((long)(GPG_ERR_BAD_SIGNATURE)));
40520 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PUBKEY",SWIG_From_long((long)(GPG_ERR_NO_PUBKEY)));
40521 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CHECKSUM",SWIG_From_long((long)(GPG_ERR_CHECKSUM)));
40522 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_BAD_PASSPHRASE)));
40523 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CIPHER_ALGO",SWIG_From_long((long)(GPG_ERR_CIPHER_ALGO)));
40524 27 : SWIG_Python_SetConstant(d, "GPG_ERR_KEYRING_OPEN",SWIG_From_long((long)(GPG_ERR_KEYRING_OPEN)));
40525 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PACKET",SWIG_From_long((long)(GPG_ERR_INV_PACKET)));
40526 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ARMOR",SWIG_From_long((long)(GPG_ERR_INV_ARMOR)));
40527 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_USER_ID",SWIG_From_long((long)(GPG_ERR_NO_USER_ID)));
40528 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SECKEY",SWIG_From_long((long)(GPG_ERR_NO_SECKEY)));
40529 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_SECKEY",SWIG_From_long((long)(GPG_ERR_WRONG_SECKEY)));
40530 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_KEY",SWIG_From_long((long)(GPG_ERR_BAD_KEY)));
40531 27 : SWIG_Python_SetConstant(d, "GPG_ERR_COMPR_ALGO",SWIG_From_long((long)(GPG_ERR_COMPR_ALGO)));
40532 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PRIME",SWIG_From_long((long)(GPG_ERR_NO_PRIME)));
40533 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENCODING_METHOD",SWIG_From_long((long)(GPG_ERR_NO_ENCODING_METHOD)));
40534 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENCRYPTION_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_ENCRYPTION_SCHEME)));
40535 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SIGNATURE_SCHEME",SWIG_From_long((long)(GPG_ERR_NO_SIGNATURE_SCHEME)));
40536 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ATTR",SWIG_From_long((long)(GPG_ERR_INV_ATTR)));
40537 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_VALUE",SWIG_From_long((long)(GPG_ERR_NO_VALUE)));
40538 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_NOT_FOUND)));
40539 27 : SWIG_Python_SetConstant(d, "GPG_ERR_VALUE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_VALUE_NOT_FOUND)));
40540 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SYNTAX",SWIG_From_long((long)(GPG_ERR_SYNTAX)));
40541 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_MPI",SWIG_From_long((long)(GPG_ERR_BAD_MPI)));
40542 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_INV_PASSPHRASE)));
40543 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SIG_CLASS",SWIG_From_long((long)(GPG_ERR_SIG_CLASS)));
40544 27 : SWIG_Python_SetConstant(d, "GPG_ERR_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_RESOURCE_LIMIT)));
40545 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYRING",SWIG_From_long((long)(GPG_ERR_INV_KEYRING)));
40546 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUSTDB",SWIG_From_long((long)(GPG_ERR_TRUSTDB)));
40547 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CERT)));
40548 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_USER_ID",SWIG_From_long((long)(GPG_ERR_INV_USER_ID)));
40549 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED",SWIG_From_long((long)(GPG_ERR_UNEXPECTED)));
40550 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TIME_CONFLICT",SWIG_From_long((long)(GPG_ERR_TIME_CONFLICT)));
40551 27 : SWIG_Python_SetConstant(d, "GPG_ERR_KEYSERVER",SWIG_From_long((long)(GPG_ERR_KEYSERVER)));
40552 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_PUBKEY_ALGO",SWIG_From_long((long)(GPG_ERR_WRONG_PUBKEY_ALGO)));
40553 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TRIBUTE_TO_D_A",SWIG_From_long((long)(GPG_ERR_TRIBUTE_TO_D_A)));
40554 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WEAK_KEY",SWIG_From_long((long)(GPG_ERR_WEAK_KEY)));
40555 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYLEN",SWIG_From_long((long)(GPG_ERR_INV_KEYLEN)));
40556 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ARG",SWIG_From_long((long)(GPG_ERR_INV_ARG)));
40557 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_URI",SWIG_From_long((long)(GPG_ERR_BAD_URI)));
40558 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_URI",SWIG_From_long((long)(GPG_ERR_INV_URI)));
40559 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NETWORK",SWIG_From_long((long)(GPG_ERR_NETWORK)));
40560 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_HOST",SWIG_From_long((long)(GPG_ERR_UNKNOWN_HOST)));
40561 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SELFTEST_FAILED",SWIG_From_long((long)(GPG_ERR_SELFTEST_FAILED)));
40562 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_ENCRYPTED",SWIG_From_long((long)(GPG_ERR_NOT_ENCRYPTED)));
40563 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_PROCESSED",SWIG_From_long((long)(GPG_ERR_NOT_PROCESSED)));
40564 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNUSABLE_PUBKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_PUBKEY)));
40565 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNUSABLE_SECKEY",SWIG_From_long((long)(GPG_ERR_UNUSABLE_SECKEY)));
40566 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_VALUE",SWIG_From_long((long)(GPG_ERR_INV_VALUE)));
40567 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_BAD_CERT_CHAIN)));
40568 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CERT)));
40569 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_DATA",SWIG_From_long((long)(GPG_ERR_NO_DATA)));
40570 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BUG",SWIG_From_long((long)(GPG_ERR_BUG)));
40571 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_NOT_SUPPORTED)));
40572 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OP",SWIG_From_long((long)(GPG_ERR_INV_OP)));
40573 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TIMEOUT",SWIG_From_long((long)(GPG_ERR_TIMEOUT)));
40574 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INTERNAL",SWIG_From_long((long)(GPG_ERR_INTERNAL)));
40575 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EOF_GCRYPT",SWIG_From_long((long)(GPG_ERR_EOF_GCRYPT)));
40576 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OBJ",SWIG_From_long((long)(GPG_ERR_INV_OBJ)));
40577 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_TOO_SHORT)));
40578 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_TOO_LARGE)));
40579 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_OBJ",SWIG_From_long((long)(GPG_ERR_NO_OBJ)));
40580 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_IMPLEMENTED",SWIG_From_long((long)(GPG_ERR_NOT_IMPLEMENTED)));
40581 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CONFLICT",SWIG_From_long((long)(GPG_ERR_CONFLICT)));
40582 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CIPHER_MODE",SWIG_From_long((long)(GPG_ERR_INV_CIPHER_MODE)));
40583 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_FLAG",SWIG_From_long((long)(GPG_ERR_INV_FLAG)));
40584 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_HANDLE",SWIG_From_long((long)(GPG_ERR_INV_HANDLE)));
40585 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUNCATED",SWIG_From_long((long)(GPG_ERR_TRUNCATED)));
40586 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_INCOMPLETE_LINE)));
40587 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_INV_RESPONSE)));
40588 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_AGENT",SWIG_From_long((long)(GPG_ERR_NO_AGENT)));
40589 27 : SWIG_Python_SetConstant(d, "GPG_ERR_AGENT",SWIG_From_long((long)(GPG_ERR_AGENT)));
40590 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_DATA",SWIG_From_long((long)(GPG_ERR_INV_DATA)));
40591 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASSUAN_SERVER_FAULT",SWIG_From_long((long)(GPG_ERR_ASSUAN_SERVER_FAULT)));
40592 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASSUAN",SWIG_From_long((long)(GPG_ERR_ASSUAN)));
40593 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_SESSION_KEY",SWIG_From_long((long)(GPG_ERR_INV_SESSION_KEY)));
40594 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_SEXP",SWIG_From_long((long)(GPG_ERR_INV_SEXP)));
40595 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ALGORITHM)));
40596 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_NO_PIN_ENTRY)));
40597 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_ENTRY",SWIG_From_long((long)(GPG_ERR_PIN_ENTRY)));
40598 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PIN",SWIG_From_long((long)(GPG_ERR_BAD_PIN)));
40599 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_NAME",SWIG_From_long((long)(GPG_ERR_INV_NAME)));
40600 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_DATA",SWIG_From_long((long)(GPG_ERR_BAD_DATA)));
40601 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_PARAMETER",SWIG_From_long((long)(GPG_ERR_INV_PARAMETER)));
40602 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_CARD",SWIG_From_long((long)(GPG_ERR_WRONG_CARD)));
40603 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_DIRMNGR",SWIG_From_long((long)(GPG_ERR_NO_DIRMNGR)));
40604 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DIRMNGR",SWIG_From_long((long)(GPG_ERR_DIRMNGR)));
40605 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_REVOKED",SWIG_From_long((long)(GPG_ERR_CERT_REVOKED)));
40606 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CRL_KNOWN",SWIG_From_long((long)(GPG_ERR_NO_CRL_KNOWN)));
40607 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CRL_TOO_OLD",SWIG_From_long((long)(GPG_ERR_CRL_TOO_OLD)));
40608 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_LINE_TOO_LONG)));
40609 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_NOT_TRUSTED)));
40610 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CANCELED",SWIG_From_long((long)(GPG_ERR_CANCELED)));
40611 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CA_CERT",SWIG_From_long((long)(GPG_ERR_BAD_CA_CERT)));
40612 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_EXPIRED",SWIG_From_long((long)(GPG_ERR_CERT_EXPIRED)));
40613 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_TOO_YOUNG",SWIG_From_long((long)(GPG_ERR_CERT_TOO_YOUNG)));
40614 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CERT",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CERT)));
40615 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_SEXP",SWIG_From_long((long)(GPG_ERR_UNKNOWN_SEXP)));
40616 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTECTION)));
40617 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CORRUPTED_PROTECTION",SWIG_From_long((long)(GPG_ERR_CORRUPTED_PROTECTION)));
40618 27 : SWIG_Python_SetConstant(d, "GPG_ERR_AMBIGUOUS_NAME",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS_NAME)));
40619 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD",SWIG_From_long((long)(GPG_ERR_CARD)));
40620 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_RESET",SWIG_From_long((long)(GPG_ERR_CARD_RESET)));
40621 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_REMOVED",SWIG_From_long((long)(GPG_ERR_CARD_REMOVED)));
40622 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CARD",SWIG_From_long((long)(GPG_ERR_INV_CARD)));
40623 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_NOT_PRESENT",SWIG_From_long((long)(GPG_ERR_CARD_NOT_PRESENT)));
40624 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PKCS15_APP",SWIG_From_long((long)(GPG_ERR_NO_PKCS15_APP)));
40625 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_CONFIRMED",SWIG_From_long((long)(GPG_ERR_NOT_CONFIRMED)));
40626 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CONFIGURATION",SWIG_From_long((long)(GPG_ERR_CONFIGURATION)));
40627 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_POLICY_MATCH",SWIG_From_long((long)(GPG_ERR_NO_POLICY_MATCH)));
40628 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_INDEX",SWIG_From_long((long)(GPG_ERR_INV_INDEX)));
40629 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ID",SWIG_From_long((long)(GPG_ERR_INV_ID)));
40630 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_SCDAEMON",SWIG_From_long((long)(GPG_ERR_NO_SCDAEMON)));
40631 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SCDAEMON",SWIG_From_long((long)(GPG_ERR_SCDAEMON)));
40632 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_PROTOCOL",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_PROTOCOL)));
40633 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_PIN_METHOD",SWIG_From_long((long)(GPG_ERR_BAD_PIN_METHOD)));
40634 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CARD_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_CARD_NOT_INITIALIZED)));
40635 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_OPERATION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_OPERATION)));
40636 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_KEY_USAGE",SWIG_From_long((long)(GPG_ERR_WRONG_KEY_USAGE)));
40637 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOTHING_FOUND",SWIG_From_long((long)(GPG_ERR_NOTHING_FOUND)));
40638 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_BLOB_TYPE",SWIG_From_long((long)(GPG_ERR_WRONG_BLOB_TYPE)));
40639 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_VALUE",SWIG_From_long((long)(GPG_ERR_MISSING_VALUE)));
40640 27 : SWIG_Python_SetConstant(d, "GPG_ERR_HARDWARE",SWIG_From_long((long)(GPG_ERR_HARDWARE)));
40641 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_BLOCKED",SWIG_From_long((long)(GPG_ERR_PIN_BLOCKED)));
40642 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USE_CONDITIONS",SWIG_From_long((long)(GPG_ERR_USE_CONDITIONS)));
40643 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PIN_NOT_SYNCED",SWIG_From_long((long)(GPG_ERR_PIN_NOT_SYNCED)));
40644 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CRL",SWIG_From_long((long)(GPG_ERR_INV_CRL)));
40645 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_BER",SWIG_From_long((long)(GPG_ERR_BAD_BER)));
40646 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_BER",SWIG_From_long((long)(GPG_ERR_INV_BER)));
40647 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELEMENT_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_ELEMENT_NOT_FOUND)));
40648 27 : SWIG_Python_SetConstant(d, "GPG_ERR_IDENTIFIER_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_IDENTIFIER_NOT_FOUND)));
40649 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_TAG",SWIG_From_long((long)(GPG_ERR_INV_TAG)));
40650 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_LENGTH",SWIG_From_long((long)(GPG_ERR_INV_LENGTH)));
40651 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_KEYINFO",SWIG_From_long((long)(GPG_ERR_INV_KEYINFO)));
40652 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED_TAG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_TAG)));
40653 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_DER_ENCODED",SWIG_From_long((long)(GPG_ERR_NOT_DER_ENCODED)));
40654 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_NO_CMS_OBJ)));
40655 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CMS_OBJ)));
40656 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CMS_OBJ)));
40657 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CMS_OBJ",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_OBJ)));
40658 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_ENCODING",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_ENCODING)));
40659 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CMS_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CMS_VERSION)));
40660 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_ALGORITHM",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ALGORITHM)));
40661 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ENGINE",SWIG_From_long((long)(GPG_ERR_INV_ENGINE)));
40662 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PUBKEY_NOT_TRUSTED",SWIG_From_long((long)(GPG_ERR_PUBKEY_NOT_TRUSTED)));
40663 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DECRYPT_FAILED",SWIG_From_long((long)(GPG_ERR_DECRYPT_FAILED)));
40664 27 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_EXPIRED",SWIG_From_long((long)(GPG_ERR_KEY_EXPIRED)));
40665 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SIG_EXPIRED",SWIG_From_long((long)(GPG_ERR_SIG_EXPIRED)));
40666 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENCODING_PROBLEM",SWIG_From_long((long)(GPG_ERR_ENCODING_PROBLEM)));
40667 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_STATE",SWIG_From_long((long)(GPG_ERR_INV_STATE)));
40668 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_VALUE",SWIG_From_long((long)(GPG_ERR_DUP_VALUE)));
40669 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ACTION",SWIG_From_long((long)(GPG_ERR_MISSING_ACTION)));
40670 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MODULE_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_MODULE_NOT_FOUND)));
40671 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_OID_STRING",SWIG_From_long((long)(GPG_ERR_INV_OID_STRING)));
40672 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_TIME",SWIG_From_long((long)(GPG_ERR_INV_TIME)));
40673 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CRL_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CRL_OBJ)));
40674 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNSUPPORTED_CRL_VERSION",SWIG_From_long((long)(GPG_ERR_UNSUPPORTED_CRL_VERSION)));
40675 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CERT_OBJ",SWIG_From_long((long)(GPG_ERR_INV_CERT_OBJ)));
40676 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_NAME",SWIG_From_long((long)(GPG_ERR_UNKNOWN_NAME)));
40677 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LOCALE_PROBLEM",SWIG_From_long((long)(GPG_ERR_LOCALE_PROBLEM)));
40678 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_LOCKED",SWIG_From_long((long)(GPG_ERR_NOT_LOCKED)));
40679 27 : SWIG_Python_SetConstant(d, "GPG_ERR_PROTOCOL_VIOLATION",SWIG_From_long((long)(GPG_ERR_PROTOCOL_VIOLATION)));
40680 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_MAC",SWIG_From_long((long)(GPG_ERR_INV_MAC)));
40681 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_REQUEST",SWIG_From_long((long)(GPG_ERR_INV_REQUEST)));
40682 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_EXTN)));
40683 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CRIT_EXTN)));
40684 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LOCKED",SWIG_From_long((long)(GPG_ERR_LOCKED)));
40685 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_OPTION",SWIG_From_long((long)(GPG_ERR_UNKNOWN_OPTION)));
40686 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_COMMAND",SWIG_From_long((long)(GPG_ERR_UNKNOWN_COMMAND)));
40687 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_OPERATIONAL",SWIG_From_long((long)(GPG_ERR_NOT_OPERATIONAL)));
40688 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PASSPHRASE",SWIG_From_long((long)(GPG_ERR_NO_PASSPHRASE)));
40689 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_PIN",SWIG_From_long((long)(GPG_ERR_NO_PIN)));
40690 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_ENABLED",SWIG_From_long((long)(GPG_ERR_NOT_ENABLED)));
40691 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_ENGINE",SWIG_From_long((long)(GPG_ERR_NO_ENGINE)));
40692 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_KEY",SWIG_From_long((long)(GPG_ERR_MISSING_KEY)));
40693 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_MANY",SWIG_From_long((long)(GPG_ERR_TOO_MANY)));
40694 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LIMIT_REACHED",SWIG_From_long((long)(GPG_ERR_LIMIT_REACHED)));
40695 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NOT_INITIALIZED",SWIG_From_long((long)(GPG_ERR_NOT_INITIALIZED)));
40696 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ISSUER_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_ISSUER_CERT)));
40697 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_KEYSERVER",SWIG_From_long((long)(GPG_ERR_NO_KEYSERVER)));
40698 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_CURVE",SWIG_From_long((long)(GPG_ERR_INV_CURVE)));
40699 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_CURVE",SWIG_From_long((long)(GPG_ERR_UNKNOWN_CURVE)));
40700 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_KEY",SWIG_From_long((long)(GPG_ERR_DUP_KEY)));
40701 27 : SWIG_Python_SetConstant(d, "GPG_ERR_AMBIGUOUS",SWIG_From_long((long)(GPG_ERR_AMBIGUOUS)));
40702 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_NO_CRYPT_CTX)));
40703 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WRONG_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_WRONG_CRYPT_CTX)));
40704 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_CRYPT_CTX",SWIG_From_long((long)(GPG_ERR_BAD_CRYPT_CTX)));
40705 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CRYPT_CTX_CONFLICT",SWIG_From_long((long)(GPG_ERR_CRYPT_CTX_CONFLICT)));
40706 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BROKEN_PUBKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_PUBKEY)));
40707 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BROKEN_SECKEY",SWIG_From_long((long)(GPG_ERR_BROKEN_SECKEY)));
40708 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MAC_ALGO",SWIG_From_long((long)(GPG_ERR_MAC_ALGO)));
40709 27 : SWIG_Python_SetConstant(d, "GPG_ERR_FULLY_CANCELED",SWIG_From_long((long)(GPG_ERR_FULLY_CANCELED)));
40710 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNFINISHED",SWIG_From_long((long)(GPG_ERR_UNFINISHED)));
40711 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BUFFER_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_BUFFER_TOO_SHORT)));
40712 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_INV_LEN_SPEC",SWIG_From_long((long)(GPG_ERR_SEXP_INV_LEN_SPEC)));
40713 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_STRING_TOO_LONG",SWIG_From_long((long)(GPG_ERR_SEXP_STRING_TOO_LONG)));
40714 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNMATCHED_PAREN",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_PAREN)));
40715 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_NOT_CANONICAL",SWIG_From_long((long)(GPG_ERR_SEXP_NOT_CANONICAL)));
40716 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_CHARACTER",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_CHARACTER)));
40717 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_QUOTATION",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_QUOTATION)));
40718 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_ZERO_PREFIX",SWIG_From_long((long)(GPG_ERR_SEXP_ZERO_PREFIX)));
40719 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_NESTED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_NESTED_DH)));
40720 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNMATCHED_DH",SWIG_From_long((long)(GPG_ERR_SEXP_UNMATCHED_DH)));
40721 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_UNEXPECTED_PUNC",SWIG_From_long((long)(GPG_ERR_SEXP_UNEXPECTED_PUNC)));
40722 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_HEX_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_HEX_CHAR)));
40723 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_ODD_HEX_NUMBERS",SWIG_From_long((long)(GPG_ERR_SEXP_ODD_HEX_NUMBERS)));
40724 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SEXP_BAD_OCT_CHAR",SWIG_From_long((long)(GPG_ERR_SEXP_BAD_OCT_CHAR)));
40725 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SUBKEYS_EXP_OR_REV",SWIG_From_long((long)(GPG_ERR_SUBKEYS_EXP_OR_REV)));
40726 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DB_CORRUPTED",SWIG_From_long((long)(GPG_ERR_DB_CORRUPTED)));
40727 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SERVER_FAILED",SWIG_From_long((long)(GPG_ERR_SERVER_FAILED)));
40728 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_NAME",SWIG_From_long((long)(GPG_ERR_NO_NAME)));
40729 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_KEY",SWIG_From_long((long)(GPG_ERR_NO_KEY)));
40730 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LEGACY_KEY",SWIG_From_long((long)(GPG_ERR_LEGACY_KEY)));
40731 27 : SWIG_Python_SetConstant(d, "GPG_ERR_REQUEST_TOO_SHORT",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_SHORT)));
40732 27 : SWIG_Python_SetConstant(d, "GPG_ERR_REQUEST_TOO_LONG",SWIG_From_long((long)(GPG_ERR_REQUEST_TOO_LONG)));
40733 27 : SWIG_Python_SetConstant(d, "GPG_ERR_OBJ_TERM_STATE",SWIG_From_long((long)(GPG_ERR_OBJ_TERM_STATE)));
40734 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CERT_CHAIN",SWIG_From_long((long)(GPG_ERR_NO_CERT_CHAIN)));
40735 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CERT_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_CERT_TOO_LARGE)));
40736 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_RECORD",SWIG_From_long((long)(GPG_ERR_INV_RECORD)));
40737 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_MAC",SWIG_From_long((long)(GPG_ERR_BAD_MAC)));
40738 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNEXPECTED_MSG",SWIG_From_long((long)(GPG_ERR_UNEXPECTED_MSG)));
40739 27 : SWIG_Python_SetConstant(d, "GPG_ERR_COMPR_FAILED",SWIG_From_long((long)(GPG_ERR_COMPR_FAILED)));
40740 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WOULD_WRAP",SWIG_From_long((long)(GPG_ERR_WOULD_WRAP)));
40741 27 : SWIG_Python_SetConstant(d, "GPG_ERR_FATAL_ALERT",SWIG_From_long((long)(GPG_ERR_FATAL_ALERT)));
40742 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NO_CIPHER",SWIG_From_long((long)(GPG_ERR_NO_CIPHER)));
40743 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_CLIENT_CERT",SWIG_From_long((long)(GPG_ERR_MISSING_CLIENT_CERT)));
40744 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CLOSE_NOTIFY",SWIG_From_long((long)(GPG_ERR_CLOSE_NOTIFY)));
40745 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TICKET_EXPIRED",SWIG_From_long((long)(GPG_ERR_TICKET_EXPIRED)));
40746 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_TICKET",SWIG_From_long((long)(GPG_ERR_BAD_TICKET)));
40747 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_IDENTITY",SWIG_From_long((long)(GPG_ERR_UNKNOWN_IDENTITY)));
40748 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT)));
40749 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT_REQ",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_REQ)));
40750 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CERT_VER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CERT_VER)));
40751 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CHANGE_CIPHER",SWIG_From_long((long)(GPG_ERR_BAD_HS_CHANGE_CIPHER)));
40752 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CLIENT_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_HELLO)));
40753 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_HELLO",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO)));
40754 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_HELLO_DONE",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_HELLO_DONE)));
40755 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_FINISHED",SWIG_From_long((long)(GPG_ERR_BAD_HS_FINISHED)));
40756 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_SERVER_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_SERVER_KEX)));
40757 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BAD_HS_CLIENT_KEX",SWIG_From_long((long)(GPG_ERR_BAD_HS_CLIENT_KEX)));
40758 27 : SWIG_Python_SetConstant(d, "GPG_ERR_BOGUS_STRING",SWIG_From_long((long)(GPG_ERR_BOGUS_STRING)));
40759 27 : SWIG_Python_SetConstant(d, "GPG_ERR_FORBIDDEN",SWIG_From_long((long)(GPG_ERR_FORBIDDEN)));
40760 27 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_DISABLED",SWIG_From_long((long)(GPG_ERR_KEY_DISABLED)));
40761 27 : SWIG_Python_SetConstant(d, "GPG_ERR_KEY_ON_CARD",SWIG_From_long((long)(GPG_ERR_KEY_ON_CARD)));
40762 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_LOCK_OBJ",SWIG_From_long((long)(GPG_ERR_INV_LOCK_OBJ)));
40763 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TRUE",SWIG_From_long((long)(GPG_ERR_TRUE)));
40764 27 : SWIG_Python_SetConstant(d, "GPG_ERR_FALSE",SWIG_From_long((long)(GPG_ERR_FALSE)));
40765 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_GENERAL",SWIG_From_long((long)(GPG_ERR_ASS_GENERAL)));
40766 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_ACCEPT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_ACCEPT_FAILED)));
40767 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_CONNECT_FAILED",SWIG_From_long((long)(GPG_ERR_ASS_CONNECT_FAILED)));
40768 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INV_RESPONSE",SWIG_From_long((long)(GPG_ERR_ASS_INV_RESPONSE)));
40769 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INV_VALUE",SWIG_From_long((long)(GPG_ERR_ASS_INV_VALUE)));
40770 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_INCOMPLETE_LINE",SWIG_From_long((long)(GPG_ERR_ASS_INCOMPLETE_LINE)));
40771 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_LINE_TOO_LONG",SWIG_From_long((long)(GPG_ERR_ASS_LINE_TOO_LONG)));
40772 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NESTED_COMMANDS",SWIG_From_long((long)(GPG_ERR_ASS_NESTED_COMMANDS)));
40773 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_DATA_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_DATA_CB)));
40774 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_INQUIRE_CB",SWIG_From_long((long)(GPG_ERR_ASS_NO_INQUIRE_CB)));
40775 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NOT_A_SERVER",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_SERVER)));
40776 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NOT_A_CLIENT",SWIG_From_long((long)(GPG_ERR_ASS_NOT_A_CLIENT)));
40777 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_SERVER_START",SWIG_From_long((long)(GPG_ERR_ASS_SERVER_START)));
40778 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_READ_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_READ_ERROR)));
40779 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_WRITE_ERROR",SWIG_From_long((long)(GPG_ERR_ASS_WRITE_ERROR)));
40780 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_TOO_MUCH_DATA",SWIG_From_long((long)(GPG_ERR_ASS_TOO_MUCH_DATA)));
40781 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNEXPECTED_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNEXPECTED_CMD)));
40782 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNKNOWN_CMD",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_CMD)));
40783 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_SYNTAX",SWIG_From_long((long)(GPG_ERR_ASS_SYNTAX)));
40784 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_CANCELED",SWIG_From_long((long)(GPG_ERR_ASS_CANCELED)));
40785 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_INPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_INPUT)));
40786 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_NO_OUTPUT",SWIG_From_long((long)(GPG_ERR_ASS_NO_OUTPUT)));
40787 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_PARAMETER",SWIG_From_long((long)(GPG_ERR_ASS_PARAMETER)));
40788 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ASS_UNKNOWN_INQUIRE",SWIG_From_long((long)(GPG_ERR_ASS_UNKNOWN_INQUIRE)));
40789 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENGINE_TOO_OLD",SWIG_From_long((long)(GPG_ERR_ENGINE_TOO_OLD)));
40790 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WINDOW_TOO_SMALL",SWIG_From_long((long)(GPG_ERR_WINDOW_TOO_SMALL)));
40791 27 : SWIG_Python_SetConstant(d, "GPG_ERR_WINDOW_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_WINDOW_TOO_LARGE)));
40792 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ENVVAR",SWIG_From_long((long)(GPG_ERR_MISSING_ENVVAR)));
40793 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_ID_EXISTS",SWIG_From_long((long)(GPG_ERR_USER_ID_EXISTS)));
40794 27 : SWIG_Python_SetConstant(d, "GPG_ERR_NAME_EXISTS",SWIG_From_long((long)(GPG_ERR_NAME_EXISTS)));
40795 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DUP_NAME",SWIG_From_long((long)(GPG_ERR_DUP_NAME)));
40796 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_YOUNG",SWIG_From_long((long)(GPG_ERR_TOO_YOUNG)));
40797 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TOO_OLD",SWIG_From_long((long)(GPG_ERR_TOO_OLD)));
40798 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_FLAG",SWIG_From_long((long)(GPG_ERR_UNKNOWN_FLAG)));
40799 27 : SWIG_Python_SetConstant(d, "GPG_ERR_INV_ORDER",SWIG_From_long((long)(GPG_ERR_INV_ORDER)));
40800 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ALREADY_FETCHED",SWIG_From_long((long)(GPG_ERR_ALREADY_FETCHED)));
40801 27 : SWIG_Python_SetConstant(d, "GPG_ERR_TRY_LATER",SWIG_From_long((long)(GPG_ERR_TRY_LATER)));
40802 27 : SWIG_Python_SetConstant(d, "GPG_ERR_SYSTEM_BUG",SWIG_From_long((long)(GPG_ERR_SYSTEM_BUG)));
40803 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_UNKNOWN",SWIG_From_long((long)(GPG_ERR_DNS_UNKNOWN)));
40804 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_SECTION",SWIG_From_long((long)(GPG_ERR_DNS_SECTION)));
40805 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_ADDRESS",SWIG_From_long((long)(GPG_ERR_DNS_ADDRESS)));
40806 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_NO_QUERY",SWIG_From_long((long)(GPG_ERR_DNS_NO_QUERY)));
40807 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_NO_ANSWER",SWIG_From_long((long)(GPG_ERR_DNS_NO_ANSWER)));
40808 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_CLOSED",SWIG_From_long((long)(GPG_ERR_DNS_CLOSED)));
40809 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_VERIFY",SWIG_From_long((long)(GPG_ERR_DNS_VERIFY)));
40810 27 : SWIG_Python_SetConstant(d, "GPG_ERR_DNS_TIMEOUT",SWIG_From_long((long)(GPG_ERR_DNS_TIMEOUT)));
40811 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_GENERAL)));
40812 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ATTR_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_ATTR_GENERAL)));
40813 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NAME_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_NAME_GENERAL)));
40814 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SECURITY_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SECURITY_GENERAL)));
40815 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SERVICE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_SERVICE_GENERAL)));
40816 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UPDATE_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_UPDATE_GENERAL)));
40817 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_E_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_E_GENERAL)));
40818 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_X_GENERAL)));
40819 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OTHER_GENERAL",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER_GENERAL)));
40820 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_CONNECTING",SWIG_From_long((long)(GPG_ERR_LDAP_X_CONNECTING)));
40821 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_REFERRAL_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL_LIMIT)));
40822 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CLIENT_LOOP",SWIG_From_long((long)(GPG_ERR_LDAP_CLIENT_LOOP)));
40823 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_RESULTS)));
40824 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONTROL_NOT_FOUND",SWIG_From_long((long)(GPG_ERR_LDAP_CONTROL_NOT_FOUND)));
40825 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_SUPPORTED",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_SUPPORTED)));
40826 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONNECT",SWIG_From_long((long)(GPG_ERR_LDAP_CONNECT)));
40827 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_MEMORY",SWIG_From_long((long)(GPG_ERR_LDAP_NO_MEMORY)));
40828 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PARAM",SWIG_From_long((long)(GPG_ERR_LDAP_PARAM)));
40829 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_USER_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_USER_CANCELLED)));
40830 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_FILTER",SWIG_From_long((long)(GPG_ERR_LDAP_FILTER)));
40831 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_AUTH_UNKNOWN",SWIG_From_long((long)(GPG_ERR_LDAP_AUTH_UNKNOWN)));
40832 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TIMEOUT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMEOUT)));
40833 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_DECODING",SWIG_From_long((long)(GPG_ERR_LDAP_DECODING)));
40834 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ENCODING",SWIG_From_long((long)(GPG_ERR_LDAP_ENCODING)));
40835 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_LOCAL",SWIG_From_long((long)(GPG_ERR_LDAP_LOCAL)));
40836 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SERVER_DOWN",SWIG_From_long((long)(GPG_ERR_LDAP_SERVER_DOWN)));
40837 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SUCCESS",SWIG_From_long((long)(GPG_ERR_LDAP_SUCCESS)));
40838 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OPERATIONS",SWIG_From_long((long)(GPG_ERR_LDAP_OPERATIONS)));
40839 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PROTOCOL",SWIG_From_long((long)(GPG_ERR_LDAP_PROTOCOL)));
40840 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TIMELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_TIMELIMIT)));
40841 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SIZELIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_SIZELIMIT)));
40842 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_COMPARE_FALSE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_FALSE)));
40843 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_COMPARE_TRUE",SWIG_From_long((long)(GPG_ERR_LDAP_COMPARE_TRUE)));
40844 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNSUPPORTED_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_UNSUPPORTED_AUTH)));
40845 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_STRONG_AUTH_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_STRONG_AUTH_RQRD)));
40846 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PARTIAL_RESULTS",SWIG_From_long((long)(GPG_ERR_LDAP_PARTIAL_RESULTS)));
40847 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_REFERRAL",SWIG_From_long((long)(GPG_ERR_LDAP_REFERRAL)));
40848 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ADMINLIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_ADMINLIMIT)));
40849 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAIL_CRIT_EXTN)));
40850 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONFIDENT_RQRD",SWIG_From_long((long)(GPG_ERR_LDAP_CONFIDENT_RQRD)));
40851 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_SASL_BIND_INPROG",SWIG_From_long((long)(GPG_ERR_LDAP_SASL_BIND_INPROG)));
40852 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_ATTRIBUTE)));
40853 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNDEFINED_TYPE",SWIG_From_long((long)(GPG_ERR_LDAP_UNDEFINED_TYPE)));
40854 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BAD_MATCHING",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_MATCHING)));
40855 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CONST_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CONST_VIOLATION)));
40856 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TYPE_VALUE_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_TYPE_VALUE_EXISTS)));
40857 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_SYNTAX)));
40858 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_OBJ",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OBJ)));
40859 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALIAS_PROBLEM",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_PROBLEM)));
40860 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_DN_SYNTAX",SWIG_From_long((long)(GPG_ERR_LDAP_INV_DN_SYNTAX)));
40861 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_IS_LEAF",SWIG_From_long((long)(GPG_ERR_LDAP_IS_LEAF)));
40862 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALIAS_DEREF",SWIG_From_long((long)(GPG_ERR_LDAP_ALIAS_DEREF)));
40863 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_X_PROXY_AUTH_FAIL",SWIG_From_long((long)(GPG_ERR_LDAP_X_PROXY_AUTH_FAIL)));
40864 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BAD_AUTH",SWIG_From_long((long)(GPG_ERR_LDAP_BAD_AUTH)));
40865 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INV_CREDENTIALS",SWIG_From_long((long)(GPG_ERR_LDAP_INV_CREDENTIALS)));
40866 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_INSUFFICIENT_ACC",SWIG_From_long((long)(GPG_ERR_LDAP_INSUFFICIENT_ACC)));
40867 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_BUSY",SWIG_From_long((long)(GPG_ERR_LDAP_BUSY)));
40868 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNAVAILABLE",SWIG_From_long((long)(GPG_ERR_LDAP_UNAVAILABLE)));
40869 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_UNWILL_TO_PERFORM",SWIG_From_long((long)(GPG_ERR_LDAP_UNWILL_TO_PERFORM)));
40870 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_LOOP_DETECT",SWIG_From_long((long)(GPG_ERR_LDAP_LOOP_DETECT)));
40871 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NAMING_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_NAMING_VIOLATION)));
40872 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OBJ_CLS_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_OBJ_CLS_VIOLATION)));
40873 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_ALLOW_NONLEAF",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_NONLEAF)));
40874 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NOT_ALLOW_ON_RDN",SWIG_From_long((long)(GPG_ERR_LDAP_NOT_ALLOW_ON_RDN)));
40875 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ALREADY_EXISTS",SWIG_From_long((long)(GPG_ERR_LDAP_ALREADY_EXISTS)));
40876 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_OBJ_CLASS_MODS",SWIG_From_long((long)(GPG_ERR_LDAP_NO_OBJ_CLASS_MODS)));
40877 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_RESULTS_TOO_LARGE",SWIG_From_long((long)(GPG_ERR_LDAP_RESULTS_TOO_LARGE)));
40878 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_AFFECTS_MULT_DSAS",SWIG_From_long((long)(GPG_ERR_LDAP_AFFECTS_MULT_DSAS)));
40879 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_VLV",SWIG_From_long((long)(GPG_ERR_LDAP_VLV)));
40880 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_OTHER",SWIG_From_long((long)(GPG_ERR_LDAP_OTHER)));
40881 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_RESOURCE_LIMIT",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RESOURCE_LIMIT)));
40882 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_SEC_VIOLATION",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_SEC_VIOLATION)));
40883 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_INV_DATA",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_INV_DATA)));
40884 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_UNSUP_SCHEME",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_UNSUP_SCHEME)));
40885 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CUP_RELOAD",SWIG_From_long((long)(GPG_ERR_LDAP_CUP_RELOAD)));
40886 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CANCELLED",SWIG_From_long((long)(GPG_ERR_LDAP_CANCELLED)));
40887 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_NO_SUCH_OPERATION",SWIG_From_long((long)(GPG_ERR_LDAP_NO_SUCH_OPERATION)));
40888 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_TOO_LATE",SWIG_From_long((long)(GPG_ERR_LDAP_TOO_LATE)));
40889 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_CANNOT_CANCEL",SWIG_From_long((long)(GPG_ERR_LDAP_CANNOT_CANCEL)));
40890 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_ASSERTION_FAILED",SWIG_From_long((long)(GPG_ERR_LDAP_ASSERTION_FAILED)));
40891 27 : SWIG_Python_SetConstant(d, "GPG_ERR_LDAP_PROX_AUTH_DENIED",SWIG_From_long((long)(GPG_ERR_LDAP_PROX_AUTH_DENIED)));
40892 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_1",SWIG_From_long((long)(GPG_ERR_USER_1)));
40893 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_2",SWIG_From_long((long)(GPG_ERR_USER_2)));
40894 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_3",SWIG_From_long((long)(GPG_ERR_USER_3)));
40895 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_4",SWIG_From_long((long)(GPG_ERR_USER_4)));
40896 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_5",SWIG_From_long((long)(GPG_ERR_USER_5)));
40897 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_6",SWIG_From_long((long)(GPG_ERR_USER_6)));
40898 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_7",SWIG_From_long((long)(GPG_ERR_USER_7)));
40899 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_8",SWIG_From_long((long)(GPG_ERR_USER_8)));
40900 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_9",SWIG_From_long((long)(GPG_ERR_USER_9)));
40901 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_10",SWIG_From_long((long)(GPG_ERR_USER_10)));
40902 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_11",SWIG_From_long((long)(GPG_ERR_USER_11)));
40903 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_12",SWIG_From_long((long)(GPG_ERR_USER_12)));
40904 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_13",SWIG_From_long((long)(GPG_ERR_USER_13)));
40905 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_14",SWIG_From_long((long)(GPG_ERR_USER_14)));
40906 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_15",SWIG_From_long((long)(GPG_ERR_USER_15)));
40907 27 : SWIG_Python_SetConstant(d, "GPG_ERR_USER_16",SWIG_From_long((long)(GPG_ERR_USER_16)));
40908 27 : SWIG_Python_SetConstant(d, "GPG_ERR_MISSING_ERRNO",SWIG_From_long((long)(GPG_ERR_MISSING_ERRNO)));
40909 27 : SWIG_Python_SetConstant(d, "GPG_ERR_UNKNOWN_ERRNO",SWIG_From_long((long)(GPG_ERR_UNKNOWN_ERRNO)));
40910 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EOF",SWIG_From_long((long)(GPG_ERR_EOF)));
40911 27 : SWIG_Python_SetConstant(d, "GPG_ERR_E2BIG",SWIG_From_long((long)(GPG_ERR_E2BIG)));
40912 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EACCES",SWIG_From_long((long)(GPG_ERR_EACCES)));
40913 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EADDRINUSE",SWIG_From_long((long)(GPG_ERR_EADDRINUSE)));
40914 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EADDRNOTAVAIL",SWIG_From_long((long)(GPG_ERR_EADDRNOTAVAIL)));
40915 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EADV",SWIG_From_long((long)(GPG_ERR_EADV)));
40916 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EAFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EAFNOSUPPORT)));
40917 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EAGAIN",SWIG_From_long((long)(GPG_ERR_EAGAIN)));
40918 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EALREADY",SWIG_From_long((long)(GPG_ERR_EALREADY)));
40919 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EAUTH",SWIG_From_long((long)(GPG_ERR_EAUTH)));
40920 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBACKGROUND",SWIG_From_long((long)(GPG_ERR_EBACKGROUND)));
40921 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADE",SWIG_From_long((long)(GPG_ERR_EBADE)));
40922 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADF",SWIG_From_long((long)(GPG_ERR_EBADF)));
40923 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADFD",SWIG_From_long((long)(GPG_ERR_EBADFD)));
40924 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADMSG",SWIG_From_long((long)(GPG_ERR_EBADMSG)));
40925 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADR",SWIG_From_long((long)(GPG_ERR_EBADR)));
40926 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADRPC",SWIG_From_long((long)(GPG_ERR_EBADRPC)));
40927 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADRQC",SWIG_From_long((long)(GPG_ERR_EBADRQC)));
40928 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBADSLT",SWIG_From_long((long)(GPG_ERR_EBADSLT)));
40929 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBFONT",SWIG_From_long((long)(GPG_ERR_EBFONT)));
40930 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EBUSY",SWIG_From_long((long)(GPG_ERR_EBUSY)));
40931 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECANCELED",SWIG_From_long((long)(GPG_ERR_ECANCELED)));
40932 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECHILD",SWIG_From_long((long)(GPG_ERR_ECHILD)));
40933 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECHRNG",SWIG_From_long((long)(GPG_ERR_ECHRNG)));
40934 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECOMM",SWIG_From_long((long)(GPG_ERR_ECOMM)));
40935 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNABORTED",SWIG_From_long((long)(GPG_ERR_ECONNABORTED)));
40936 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNREFUSED",SWIG_From_long((long)(GPG_ERR_ECONNREFUSED)));
40937 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ECONNRESET",SWIG_From_long((long)(GPG_ERR_ECONNRESET)));
40938 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ED",SWIG_From_long((long)(GPG_ERR_ED)));
40939 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDEADLK",SWIG_From_long((long)(GPG_ERR_EDEADLK)));
40940 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDEADLOCK",SWIG_From_long((long)(GPG_ERR_EDEADLOCK)));
40941 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDESTADDRREQ",SWIG_From_long((long)(GPG_ERR_EDESTADDRREQ)));
40942 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDIED",SWIG_From_long((long)(GPG_ERR_EDIED)));
40943 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDOM",SWIG_From_long((long)(GPG_ERR_EDOM)));
40944 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDOTDOT",SWIG_From_long((long)(GPG_ERR_EDOTDOT)));
40945 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EDQUOT",SWIG_From_long((long)(GPG_ERR_EDQUOT)));
40946 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EEXIST",SWIG_From_long((long)(GPG_ERR_EEXIST)));
40947 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EFAULT",SWIG_From_long((long)(GPG_ERR_EFAULT)));
40948 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EFBIG",SWIG_From_long((long)(GPG_ERR_EFBIG)));
40949 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EFTYPE",SWIG_From_long((long)(GPG_ERR_EFTYPE)));
40950 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EGRATUITOUS",SWIG_From_long((long)(GPG_ERR_EGRATUITOUS)));
40951 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EGREGIOUS",SWIG_From_long((long)(GPG_ERR_EGREGIOUS)));
40952 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EHOSTDOWN",SWIG_From_long((long)(GPG_ERR_EHOSTDOWN)));
40953 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EHOSTUNREACH",SWIG_From_long((long)(GPG_ERR_EHOSTUNREACH)));
40954 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EIDRM",SWIG_From_long((long)(GPG_ERR_EIDRM)));
40955 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EIEIO",SWIG_From_long((long)(GPG_ERR_EIEIO)));
40956 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EILSEQ",SWIG_From_long((long)(GPG_ERR_EILSEQ)));
40957 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EINPROGRESS",SWIG_From_long((long)(GPG_ERR_EINPROGRESS)));
40958 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EINTR",SWIG_From_long((long)(GPG_ERR_EINTR)));
40959 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EINVAL",SWIG_From_long((long)(GPG_ERR_EINVAL)));
40960 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EIO",SWIG_From_long((long)(GPG_ERR_EIO)));
40961 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EISCONN",SWIG_From_long((long)(GPG_ERR_EISCONN)));
40962 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EISDIR",SWIG_From_long((long)(GPG_ERR_EISDIR)));
40963 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EISNAM",SWIG_From_long((long)(GPG_ERR_EISNAM)));
40964 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EL2HLT",SWIG_From_long((long)(GPG_ERR_EL2HLT)));
40965 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EL2NSYNC",SWIG_From_long((long)(GPG_ERR_EL2NSYNC)));
40966 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EL3HLT",SWIG_From_long((long)(GPG_ERR_EL3HLT)));
40967 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EL3RST",SWIG_From_long((long)(GPG_ERR_EL3RST)));
40968 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBACC",SWIG_From_long((long)(GPG_ERR_ELIBACC)));
40969 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBBAD",SWIG_From_long((long)(GPG_ERR_ELIBBAD)));
40970 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBEXEC",SWIG_From_long((long)(GPG_ERR_ELIBEXEC)));
40971 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBMAX",SWIG_From_long((long)(GPG_ERR_ELIBMAX)));
40972 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELIBSCN",SWIG_From_long((long)(GPG_ERR_ELIBSCN)));
40973 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELNRNG",SWIG_From_long((long)(GPG_ERR_ELNRNG)));
40974 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ELOOP",SWIG_From_long((long)(GPG_ERR_ELOOP)));
40975 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EMEDIUMTYPE",SWIG_From_long((long)(GPG_ERR_EMEDIUMTYPE)));
40976 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EMFILE",SWIG_From_long((long)(GPG_ERR_EMFILE)));
40977 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EMLINK",SWIG_From_long((long)(GPG_ERR_EMLINK)));
40978 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EMSGSIZE",SWIG_From_long((long)(GPG_ERR_EMSGSIZE)));
40979 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EMULTIHOP",SWIG_From_long((long)(GPG_ERR_EMULTIHOP)));
40980 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENAMETOOLONG",SWIG_From_long((long)(GPG_ERR_ENAMETOOLONG)));
40981 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENAVAIL",SWIG_From_long((long)(GPG_ERR_ENAVAIL)));
40982 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENEEDAUTH",SWIG_From_long((long)(GPG_ERR_ENEEDAUTH)));
40983 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETDOWN",SWIG_From_long((long)(GPG_ERR_ENETDOWN)));
40984 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETRESET",SWIG_From_long((long)(GPG_ERR_ENETRESET)));
40985 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENETUNREACH",SWIG_From_long((long)(GPG_ERR_ENETUNREACH)));
40986 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENFILE",SWIG_From_long((long)(GPG_ERR_ENFILE)));
40987 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOANO",SWIG_From_long((long)(GPG_ERR_ENOANO)));
40988 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOBUFS",SWIG_From_long((long)(GPG_ERR_ENOBUFS)));
40989 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOCSI",SWIG_From_long((long)(GPG_ERR_ENOCSI)));
40990 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENODATA",SWIG_From_long((long)(GPG_ERR_ENODATA)));
40991 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENODEV",SWIG_From_long((long)(GPG_ERR_ENODEV)));
40992 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOENT",SWIG_From_long((long)(GPG_ERR_ENOENT)));
40993 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOEXEC",SWIG_From_long((long)(GPG_ERR_ENOEXEC)));
40994 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOLCK",SWIG_From_long((long)(GPG_ERR_ENOLCK)));
40995 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOLINK",SWIG_From_long((long)(GPG_ERR_ENOLINK)));
40996 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMEDIUM",SWIG_From_long((long)(GPG_ERR_ENOMEDIUM)));
40997 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMEM",SWIG_From_long((long)(GPG_ERR_ENOMEM)));
40998 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOMSG",SWIG_From_long((long)(GPG_ERR_ENOMSG)));
40999 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENONET",SWIG_From_long((long)(GPG_ERR_ENONET)));
41000 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOPKG",SWIG_From_long((long)(GPG_ERR_ENOPKG)));
41001 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOPROTOOPT",SWIG_From_long((long)(GPG_ERR_ENOPROTOOPT)));
41002 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSPC",SWIG_From_long((long)(GPG_ERR_ENOSPC)));
41003 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSR",SWIG_From_long((long)(GPG_ERR_ENOSR)));
41004 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSTR",SWIG_From_long((long)(GPG_ERR_ENOSTR)));
41005 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOSYS",SWIG_From_long((long)(GPG_ERR_ENOSYS)));
41006 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTBLK",SWIG_From_long((long)(GPG_ERR_ENOTBLK)));
41007 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTCONN",SWIG_From_long((long)(GPG_ERR_ENOTCONN)));
41008 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTDIR",SWIG_From_long((long)(GPG_ERR_ENOTDIR)));
41009 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTEMPTY",SWIG_From_long((long)(GPG_ERR_ENOTEMPTY)));
41010 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTNAM",SWIG_From_long((long)(GPG_ERR_ENOTNAM)));
41011 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTSOCK",SWIG_From_long((long)(GPG_ERR_ENOTSOCK)));
41012 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTSUP",SWIG_From_long((long)(GPG_ERR_ENOTSUP)));
41013 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTTY",SWIG_From_long((long)(GPG_ERR_ENOTTY)));
41014 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENOTUNIQ",SWIG_From_long((long)(GPG_ERR_ENOTUNIQ)));
41015 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ENXIO",SWIG_From_long((long)(GPG_ERR_ENXIO)));
41016 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EOPNOTSUPP",SWIG_From_long((long)(GPG_ERR_EOPNOTSUPP)));
41017 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EOVERFLOW",SWIG_From_long((long)(GPG_ERR_EOVERFLOW)));
41018 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPERM",SWIG_From_long((long)(GPG_ERR_EPERM)));
41019 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPFNOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPFNOSUPPORT)));
41020 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPIPE",SWIG_From_long((long)(GPG_ERR_EPIPE)));
41021 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROCLIM",SWIG_From_long((long)(GPG_ERR_EPROCLIM)));
41022 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROCUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROCUNAVAIL)));
41023 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROGMISMATCH",SWIG_From_long((long)(GPG_ERR_EPROGMISMATCH)));
41024 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROGUNAVAIL",SWIG_From_long((long)(GPG_ERR_EPROGUNAVAIL)));
41025 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTO",SWIG_From_long((long)(GPG_ERR_EPROTO)));
41026 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTONOSUPPORT",SWIG_From_long((long)(GPG_ERR_EPROTONOSUPPORT)));
41027 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EPROTOTYPE",SWIG_From_long((long)(GPG_ERR_EPROTOTYPE)));
41028 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ERANGE",SWIG_From_long((long)(GPG_ERR_ERANGE)));
41029 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMCHG",SWIG_From_long((long)(GPG_ERR_EREMCHG)));
41030 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMOTE",SWIG_From_long((long)(GPG_ERR_EREMOTE)));
41031 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EREMOTEIO",SWIG_From_long((long)(GPG_ERR_EREMOTEIO)));
41032 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ERESTART",SWIG_From_long((long)(GPG_ERR_ERESTART)));
41033 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EROFS",SWIG_From_long((long)(GPG_ERR_EROFS)));
41034 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ERPCMISMATCH",SWIG_From_long((long)(GPG_ERR_ERPCMISMATCH)));
41035 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESHUTDOWN",SWIG_From_long((long)(GPG_ERR_ESHUTDOWN)));
41036 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESOCKTNOSUPPORT",SWIG_From_long((long)(GPG_ERR_ESOCKTNOSUPPORT)));
41037 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESPIPE",SWIG_From_long((long)(GPG_ERR_ESPIPE)));
41038 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESRCH",SWIG_From_long((long)(GPG_ERR_ESRCH)));
41039 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESRMNT",SWIG_From_long((long)(GPG_ERR_ESRMNT)));
41040 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESTALE",SWIG_From_long((long)(GPG_ERR_ESTALE)));
41041 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ESTRPIPE",SWIG_From_long((long)(GPG_ERR_ESTRPIPE)));
41042 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ETIME",SWIG_From_long((long)(GPG_ERR_ETIME)));
41043 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ETIMEDOUT",SWIG_From_long((long)(GPG_ERR_ETIMEDOUT)));
41044 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ETOOMANYREFS",SWIG_From_long((long)(GPG_ERR_ETOOMANYREFS)));
41045 27 : SWIG_Python_SetConstant(d, "GPG_ERR_ETXTBSY",SWIG_From_long((long)(GPG_ERR_ETXTBSY)));
41046 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EUCLEAN",SWIG_From_long((long)(GPG_ERR_EUCLEAN)));
41047 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EUNATCH",SWIG_From_long((long)(GPG_ERR_EUNATCH)));
41048 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EUSERS",SWIG_From_long((long)(GPG_ERR_EUSERS)));
41049 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EWOULDBLOCK",SWIG_From_long((long)(GPG_ERR_EWOULDBLOCK)));
41050 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EXDEV",SWIG_From_long((long)(GPG_ERR_EXDEV)));
41051 27 : SWIG_Python_SetConstant(d, "GPG_ERR_EXFULL",SWIG_From_long((long)(GPG_ERR_EXFULL)));
41052 27 : SWIG_Python_SetConstant(d, "GPG_ERR_CODE_DIM",SWIG_From_long((long)(GPG_ERR_CODE_DIM)));
41053 27 : PyDict_SetItemString(md,(char*)"cvar", SWIG_globals());
41054 27 : SWIG_addvarlink(SWIG_globals(),(char*)"gpg_in_tree_build",Swig_var_gpg_in_tree_build_get, Swig_var_gpg_in_tree_build_set);
41055 :
41056 : /* Initialize threading */
41057 27 : SWIG_PYTHON_INITIALIZE_THREADS;
41058 : #if PY_VERSION_HEX >= 0x03000000
41059 : return m;
41060 : #else
41061 27 : return;
41062 : #endif
41063 : }
41064 :
|
